Significantly improve gclient_smoketest.py

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
 import os
 import pprint
 import re
 import stat
 import subprocess
 import sys
 import time
 import unittest
 
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import scm
 
 ## Utility functions
 
 
 def addKill():
   """Add kill() method to subprocess.Popen for python <2.6"""
   if getattr(subprocess.Popen, 'kill', None):
     return
   if sys.platform == 'win32':
     def kill_win(process):
@@ skipping 112 matching lines @@
     if k not in dict2:
       diff[k] = v
     elif v != dict2[k]:
       diff[k] = (v, dict2[k])
   for k, v in dict2.iteritems():
     if k not in dict1:
       diff[k] = v
   return diff
 
 
-def mangle_svn_tree(*args):
-  result = {}
-  for old_root, new_root, tree in args:
-    for k, v in tree.iteritems():
-      if not k.startswith(old_root):
-        continue
-      result[join(new_root, k[len(old_root) + 1:]).replace(os.sep, '/')] = v
-  return result
-
-
-def mangle_git_tree(*args):
-  result = {}
-  for new_root, tree in args:
-    for k, v in tree.iteritems():
-      result[join(new_root, k)] = v
-  return result
-
-
 def commit_svn(repo):
   """Commits the changes and returns the new revision number."""
-  # Basic parsing.
   to_add = []
   to_remove = []
-  for item in Popen(['svn', 'status'],
-                    cwd=repo).communicate()[0].splitlines(False):
-    if item[0] == '?':
-      to_add.append(item[7:].strip())
-    elif item[0] == '!':
-      to_remove.append(item[7:].strip())
+  for status, filepath in scm.SVN.CaptureStatus(repo):
+    if status[0] == '?':
+      to_add.append(filepath)
+    elif status[0] == '!':
+      to_remove.append(filepath)
   if to_add:
     check_call(['svn', 'add', '--no-auto-props', '-q'] + to_add, cwd=repo)
   if to_remove:
     check_call(['svn', 'remove', '-q'] + to_remove, cwd=repo)
   proc = Popen(['svn', 'commit', repo, '-m', 'foo', '--non-interactive',
                 '--no-auth-cache', '--username', 'user1', '--password', 'foo'],
                cwd=repo)
   out, err = proc.communicate()
   match = re.search(r'revision (\d+).', out)
   if not match:
@@ skipping 44 matching lines @@
       self.SHOULD_LEAK = True
       sys.argv.remove('-l')
     elif leak is not None:
       self.SHOULD_LEAK = leak
     if host:
       self.HOST = host
     if trial_dir:
       self.TRIAL_DIR = trial_dir
 
     # Format is [ None, tree, tree, ...]
+    # i.e. revisions are 1-based.
     self.svn_revs = [None]
-    # Format is { repo: [ (hash, tree), (hash, tree), ... ], ... }
+    # 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
 
   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
@@ skipping 138 matching lines @@
 
   def setUpGIT(self):
     """Creates git repositories and start the servers."""
     if self.gitdaemon:
       return True
     self.setUp()
     if sys.platform == 'win32':
       return False
     for repo in ['repo_%d' % r for r in range(1, 5)]:
       check_call(['git', 'init', '-q', join(self.git_root, repo)])
-      self.git_hashes[repo] = []
+      self.git_hashes[repo] = [None]
 
     # Testing:
     # - dependency disapear
     # - dependency renamed
     # - versioned and unversioned reference
     # - relative and full reference
     # - deps_os
     # - var
     # - hooks
     # TODO(maruel):
@@ skipping 56 matching lines @@
                'open(\\'src/git_hooked1\\', \\'w\\').write(\\'git_hooked1\\')'],
   },
   {
     # Should not be run.
     'pattern': 'nonexistent',
     'action': ['python', '-c',
                'open(\\'src/git_hooked2\\', \\'w\\').write(\\'git_hooked2\\')'],
   },
 ]
 """ % {
+        'host': self.HOST,
+        # See self.__init__() for the format. Grab's the hash of the first
+        # commit in repo_2. Only keep the first 7 character because of:
         # TODO(maruel): http://crosbug.com/3591 We need to strip the hash.. duh.
-        'host': self.HOST,
-        'hash': self.git_hashes['repo_2'][0][0][:7]
+        'hash': self.git_hashes['repo_2'][1][0][:7]
       },
       'origin': "git/repo_1@2\n"
     })
 
     # 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)
     return True
 
   def _commit_svn(self, tree):
     self._genTree(self.svn_root, tree)
     commit_svn(self.svn_root)
     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)
     hash = commit_git(repo_root)
-    if self.git_hashes[repo]:
+    if self.git_hashes[repo][-1]:
       new_tree = self.git_hashes[repo][-1][1].copy()
       new_tree.update(tree)
     else:
       new_tree = tree.copy()
     self.git_hashes[repo].append((hash, new_tree))
 
 
 class FakeReposTestBase(unittest.TestCase):
   """This is vaguely inspired by twisted."""
 
@@ skipping 13 matching lines @@
     self.root_dir = join(self.CLASS_ROOT_DIR, self.id())
     rmtree(self.root_dir)
     os.makedirs(self.root_dir)
     self.svn_base = 'svn://%s/svn/' % self.FAKE_REPOS.HOST
     self.git_base = 'git://%s/git/' % self.FAKE_REPOS.HOST
 
   def tearDown(self):
     if not self.FAKE_REPOS.SHOULD_LEAK:
       rmtree(self.root_dir)
 
-  def checkString(self, expected, result):
+  def checkString(self, expected, result, msg=None):
     """Prints the diffs to ease debugging."""
     if expected != result:
       # Strip the begining
       while expected and result and expected[0] == result[0]:
         expected = expected[1:]
         result = result[1:]
       # The exception trace makes it hard to read so dump it too.
       if '\n' in result:
         print result
-    self.assertEquals(expected, result)
+    self.assertEquals(expected, result, msg)
 
   def check(self, expected, results):
     """Checks stdout, stderr, retcode."""
     self.checkString(expected[0], results[0])
     self.checkString(expected[1], results[1])
     self.assertEquals(expected[2], results[2])
 
   def assertTree(self, tree, tree_root=None):
     """Diff the checkout tree with a dict."""
     if not tree_root:
       tree_root = self.root_dir
     actual = read_tree(tree_root)
     diff = dict_diff(tree, actual)
     if diff:
       logging.debug('Actual %s\n%s' % (tree_root, pprint.pformat(actual)))
       logging.debug('Expected\n%s' % pprint.pformat(tree))
       logging.debug('Diff\n%s' % pprint.pformat(diff))
       self.assertEquals(diff, [])
 
+  def mangle_svn_tree(self, *args):
+    """Creates a 'virtual directory snapshot' to compare with the actual result
+    on disk."""
+    result = {}
+    for item, new_root in args:
+      old_root, rev = item.split('@', 1)
+      tree = self.FAKE_REPOS.svn_revs[int(rev)]
+      for k, v in tree.iteritems():
+        if not k.startswith(old_root):
+          continue
+        result[join(new_root, k[len(old_root) + 1:]).replace(os.sep, '/')] = v
+    return result
+
+  def mangle_git_tree(self, *args):
+    """Creates a 'virtual directory snapshot' to compare with the actual result
+    on disk."""
+    result = {}
+    for item, new_root in args:
+      repo, rev = item.split('@', 1)
+      tree = self.gittree(repo, rev)
+      for k, v in tree.iteritems():
+        result[join(new_root, k)] = v
+    return result
+
+  def githash(self, repo, rev):
+    """Sort-hand: Returns the hash for a git 'revision'."""
+    return self.FAKE_REPOS.git_hashes[repo][int(rev)][0]
+
+  def gittree(self, repo, rev):
+    """Sort-hand: returns the directory tree for a git 'revision'."""
+    return self.FAKE_REPOS.git_hashes[repo][int(rev)][1]
+
 
 def main(argv):
   fake = FakeRepos()
   print 'Using %s' % fake.trial_dir()
   try:
     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
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))