Add code to FakeReposBase to revert changes committed by a unit tests.

tests/fake_repos.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.
 
 """Generate fake repositories for testing."""
 
 import atexit
 import errno
 import logging
@@ skipping 228 matching lines @@
     # i.e. revisions are 1-based.
     self.svn_revs = [None]
     # Format is { repo: [ None, (hash, tree), (hash, tree), ... ], ... }
     # so reference looks like self.git_hashes[repo][rev][0] for hash and
     # self.git_hashes[repo][rev][1] for it's tree snapshot.
     # For consistency with self.svn_revs, it is 1-based too.
     self.git_hashes = {}
     self.svnserve = None
     self.gitdaemon = None
     self.common_init = False
+    self.repos_dir = None
+    self.git_root = None
+    self.svn_checkout = None
+    self.svn_repo = None
+    self.git_dirty = False
+    self.svn_dirty = False
 
   def trial_dir(self):
     if not self.TRIAL_DIR:
       self.TRIAL_DIR = os.path.join(
           os.path.dirname(os.path.abspath(__file__)), '_trial')
     return self.TRIAL_DIR
 
   def setUp(self):
     """All late initialization comes here.
 
-    Note that it deletes all trial_dir() and not only repos_dir."""
+    Note that it deletes all trial_dir() and not only repos_dir.
+    """
+    self.cleanup_dirt()
     if not self.common_init:
       self.common_init = True
       self.repos_dir = os.path.join(self.trial_dir(), 'repos')
       self.git_root = join(self.repos_dir, 'git')
-      self.svn_root = join(self.repos_dir, 'svn_checkout')
+      self.svn_checkout = join(self.repos_dir, 'svn_checkout')
+      self.svn_repo = join(self.repos_dir, 'svn')
       addKill()
       rmtree(self.trial_dir())
       os.makedirs(self.repos_dir)
       atexit.register(self.tearDown)
 
+  def cleanup_dirt(self):
+    """For each dirty repository, regenerate it."""
+    if self.svnserve and self.svn_dirty:
+      logging.debug('Killing svnserve pid %s' % self.svnserve.pid)
+      self.svnserve.kill()
+      self.svnserve = None
+      if not self.SHOULD_LEAK:
+        logging.debug('Removing dirty %s' % self.svn_repo)
+        rmtree(self.svn_repo)
+        logging.debug('Removing dirty %s' % self.svn_checkout)
+        rmtree(self.svn_checkout)
+      else:
+        logging.warning('Using both leaking checkout and dirty checkout')
+    if self.gitdaemon and self.git_dirty:
+      logging.debug('Killing git-daemon pid %s' % self.gitdaemon.pid)
+      self.gitdaemon.kill()
+      self.gitdaemon = None
+      if not self.SHOULD_LEAK:
+        logging.debug('Removing dirty %s' % self.git_root)
+        rmtree(self.git_root)
+      else:
+        logging.warning('Using both leaking checkout and dirty checkout')
+
   def tearDown(self):
     if self.svnserve:
       logging.debug('Killing svnserve pid %s' % self.svnserve.pid)
       self.svnserve.kill()
       self.svnserve = None
     if self.gitdaemon:
       logging.debug('Killing git-daemon pid %s' % self.gitdaemon.pid)
       self.gitdaemon.kill()
       self.gitdaemon = None
     if not self.SHOULD_LEAK:
@@ skipping 12 matching lines @@
         p = os.sep.join([root] + k_arr[:-1])
         if not os.path.isdir(p):
           os.makedirs(p)
       if v is None:
         os.remove(join(root, k))
       else:
         write(join(root, k), v)
 
   def setUpSVN(self):
     """Creates subversion repositories and start the servers."""
+    self.setUp()
     if self.svnserve:
       return True
-    self.setUp()
-    root = join(self.repos_dir, 'svn')
     try:
-      check_call(['svnadmin', 'create', root])
+      check_call(['svnadmin', 'create', self.svn_repo])
     except OSError:
       return False
-    write(join(root, 'conf', 'svnserve.conf'),
+    write(join(self.svn_repo, 'conf', 'svnserve.conf'),
         '[general]\n'
         'anon-access = read\n'
         'auth-access = write\n'
         'password-db = passwd\n')
     text = '[users]\n'
     text += ''.join('%s = %s\n' % (usr, pwd) for usr, pwd in self.USERS)
-    write(join(root, 'conf', 'passwd'), text)
+    write(join(self.svn_repo, 'conf', 'passwd'), text)
 
     # Start the daemon.
     cmd = ['svnserve', '-d', '--foreground', '-r', self.repos_dir]
     if self.HOST == '127.0.0.1':
       cmd.append('--listen-host=127.0.0.1')
-    self.svnserve = Popen(cmd, cwd=root)
+    self.svnserve = Popen(cmd, cwd=self.svn_repo)
     self.populateSvn()
+    self.svn_dirty = False
     return True
 
   def setUpGIT(self):
     """Creates git repositories and start the servers."""
+    self.setUp()
     if self.gitdaemon:
       return True
-    self.setUp()
     if sys.platform == 'win32':
       return False
     for repo in ['repo_%d' % r for r in range(1, self.NB_GIT_REPOS + 1)]:
       check_call(['git', 'init', '-q', join(self.git_root, repo)])
       self.git_hashes[repo] = [None]
     self.populateGit()
     # Start the daemon.
     cmd = ['git', 'daemon', '--export-all', '--base-path=' + self.repos_dir]
     if self.HOST == '127.0.0.1':
       cmd.append('--listen=127.0.0.1')
     logging.debug(cmd)
     self.gitdaemon = Popen(cmd, cwd=self.repos_dir)
+    self.git_dirty = False
     return True
 
   def _commit_svn(self, tree):
-    self._genTree(self.svn_root, tree)
-    commit_svn(self.svn_root, self.USERS[0][0], self.USERS[0][1])
+    self._genTree(self.svn_checkout, tree)
+    commit_svn(self.svn_checkout, self.USERS[0][0], self.USERS[0][1])
     if self.svn_revs and self.svn_revs[-1]:
       new_tree = self.svn_revs[-1].copy()
       new_tree.update(tree)
     else:
       new_tree = tree.copy()
     self.svn_revs.append(new_tree)
 
   def _commit_git(self, repo, tree):
     repo_root = join(self.git_root, repo)
     self._genTree(repo_root, tree)
@@ skipping 12 matching lines @@
     raise NotImplementedError()
 
 
 class FakeRepos(FakeReposBase):
   """Implements populateSvn() and populateGit()."""
   NB_GIT_REPOS = 4
 
   def populateSvn(self):
     """Creates a few revisions of changes including DEPS files."""
     # Repos
-    check_call(['svn', 'checkout', 'svn://127.0.0.1/svn', self.svn_root, '-q',
-                '--non-interactive', '--no-auth-cache',
+    check_call(['svn', 'checkout', 'svn://127.0.0.1/svn', self.svn_checkout,
+                '-q', '--non-interactive', '--no-auth-cache',
                 '--username', self.USERS[0][0], '--password', self.USERS[0][1]])
-    assert os.path.isdir(join(self.svn_root, '.svn'))
+    assert os.path.isdir(join(self.svn_checkout, '.svn'))
     def file_system(rev, DEPS):
       fs = {
         'origin': 'svn@%(rev)d\n',
         'trunk/origin': 'svn/trunk@%(rev)d\n',
         'trunk/src/origin': 'svn/trunk/src@%(rev)d\n',
         'trunk/src/third_party/origin': 'svn/trunk/src/third_party@%(rev)d\n',
         'trunk/other/origin': 'src/trunk/other@%(rev)d\n',
         'trunk/third_party/origin': 'svn/trunk/third_party@%(rev)d\n',
         'trunk/third_party/foo/origin': 'svn/trunk/third_party/foo@%(rev)d\n',
         'trunk/third_party/prout/origin': 'svn/trunk/third_party/foo@%(rev)d\n',
@@ skipping 292 matching lines @@
     fake.setUp()
     print('Fake setup, press enter to quit or Ctrl-C to keep the checkouts.')
     sys.stdin.readline()
   except KeyboardInterrupt:
     fake.SHOULD_LEAK = True
   return 0
 
 
 # Kind of hack.
 if '-l' in sys.argv:
-  FakeRepos.SHOULD_LEAK = True
+  FakeReposBase.SHOULD_LEAK = True
+  print 'Leaking!'
   sys.argv.remove('-l')
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))