Add git-reup and friends

tests/git_common_test.py

Index: tests/git_common_test.py
diff --git a/tests/git_common_test.py b/tests/git_common_test.py
index 711543222734440c8b852ff3f3e6c284a7f5b489..940b56593e0d2900a53942dbcca9e7292c59deeb 100755
--- a/tests/git_common_test.py
+++ b/tests/git_common_test.py
@@ -27,6 +27,7 @@ class GitCommonTestBase(unittest.TestCase):
     super(GitCommonTestBase, cls).setUpClass()
     import git_common
     cls.gc = git_common
+    cls.gc.TEST_MODE = True
 
 
 class Support(GitCommonTestBase):
@@ -63,6 +64,23 @@ class Support(GitCommonTestBase):
   def testMemoizeOneThreadsafe(self):
     self._testMemoizeOneBody(threadsafe=True)
 
+  def testOnce(self):
+    testlist = []
+
+    # This works around a bug in pylint
+    once = self.gc.once
+
+    @once
+    def add_to_list():
+      testlist.append('dog')
+
+    add_to_list()
+    add_to_list()
+    add_to_list()
+    add_to_list()
+
+    self.assertEquals(testlist, ['dog'])
+
 
 def slow_square(i):
   """Helper for ScopedPoolTest.
@@ -134,15 +152,15 @@ class ProgressPrinterTest(GitCommonTestBase):
         time.sleep(0.02)
         inc()
 
-    filtered = set(x.strip() for x in stream.data)
-    rslt = set(fmt % {'count': i} for i in xrange(11))
+    filtered = {x.strip() for x in stream.data}
+    rslt = {fmt % {'count': i} for i in xrange(11)}
     self.assertSetEqual(filtered, rslt)
     self.assertGreaterEqual(stream.count, 10)
 
 
 class GitReadOnlyFunctionsTest(git_test_utils.GitRepoReadOnlyTestBase,
                                GitCommonTestBase):
-  REPO = """
+  REPO_SCHEMA = """
   A B C D
     B E D
   """
@@ -194,7 +212,7 @@ class GitReadOnlyFunctionsTest(git_test_utils.GitRepoReadOnlyTestBase,
     items = set(self.repo.commit_map.itervalues())
 
     def testfn():
-      for line in self.gc.stream('log', '--format=%H').xreadlines():
+      for line in self.gc.run_stream('log', '--format=%H').xreadlines():
         line = line.strip()
         self.assertIn(line, items)
         items.remove(line)
@@ -202,16 +220,22 @@ class GitReadOnlyFunctionsTest(git_test_utils.GitRepoReadOnlyTestBase,
     self.repo.run(testfn)
 
   def testCurrentBranch(self):
+    def cur_branch_out_of_git():
+      os.chdir('..')
+      return self.gc.current_branch()
+    self.assertIsNone(self.repo.run(cur_branch_out_of_git))
+
     self.repo.git('checkout', 'branch_D')
     self.assertEqual(self.repo.run(self.gc.current_branch), 'branch_D')
 
   def testBranches(self):
     self.assertEqual(self.repo.run(set, self.gc.branches()),
-                     set(('branch_D', 'root_A')))
+                     {'master', 'branch_D', 'root_A'})
 
-  def testTags(self):
-    self.assertEqual(set(self.repo.run(self.gc.tags)),
-                     {'tag_'+l for l in 'ABCDE'})
+  def testDormant(self):
+    self.assertFalse(self.repo.run(self.gc.is_dormant, 'master'))
+    self.repo.git('config', 'branch.master.dormant', 'true')
+    self.assertTrue(self.repo.run(self.gc.is_dormant, 'master'))
 
   def testParseCommitrefs(self):
     ret = self.repo.run(
@@ -234,6 +258,10 @@ class GitReadOnlyFunctionsTest(git_test_utils.GitRepoReadOnlyTestBase,
     with self.assertRaisesRegexp(Exception, r"one of \('master', 'bananas'\)"):
       self.repo.run(self.gc.parse_commitrefs, 'master', 'bananas')
 
+  def testTags(self):
+    self.assertEqual(set(self.repo.run(self.gc.tags)),
+                     {'tag_'+l for l in 'ABCDE'})
+
   def testTree(self):
     tree = self.repo.run(self.gc.tree, 'master:some/files')
     file1 = self.COMMIT_A['some/files/file1']['data']
@@ -279,7 +307,7 @@ class GitReadOnlyFunctionsTest(git_test_utils.GitRepoReadOnlyTestBase,
 
 class GitMutableFunctionsTest(git_test_utils.GitRepoReadWriteTestBase,
                               GitCommonTestBase):
-  REPO = ''
+  REPO_SCHEMA = ''
 
   def _intern_data(self, data):
     with tempfile.TemporaryFile() as f:
@@ -311,6 +339,25 @@ class GitMutableFunctionsTest(git_test_utils.GitRepoReadWriteTestBase,
     self.assertEquals(self.repo.run(self.gc.config_list, 'happy.derpies'),
                       ['food', 'cat'])
 
+    self.assertEquals('cat', self.repo.run(self.gc.config, 'dude.bob', 'cat'))
+
+    self.repo.run(self.gc.set_config, 'dude.bob', 'dog')
+
+    self.assertEquals('dog', self.repo.run(self.gc.config, 'dude.bob', 'cat'))
+
+    self.repo.run(self.gc.del_config, 'dude.bob')
+
+    # This should work without raising an exception
+    self.repo.run(self.gc.del_config, 'dude.bob')
+
+    self.assertEquals('cat', self.repo.run(self.gc.config, 'dude.bob', 'cat'))
+
+    self.assertEquals('origin/master', self.repo.run(self.gc.root))
+
+    self.repo.git('config', 'depot-tools.upstream', 'catfood')
+
+    self.assertEquals('catfood', self.repo.run(self.gc.root))
+
   def testUpstream(self):
     self.repo.git('commit', '--allow-empty', '-am', 'foooooo')
     self.assertEquals(self.repo.run(self.gc.upstream, 'bobly'), None)
@@ -320,6 +367,246 @@ class GitMutableFunctionsTest(git_test_utils.GitRepoReadWriteTestBase,
                       'master')
 
 
+class GitMutableStructuredTest(git_test_utils.GitRepoReadWriteTestBase,
+                               GitCommonTestBase):
+  REPO_SCHEMA = """
+  A B C D E F G
+    B H I J K
+          J L
+
+  X Y Z
+  """
+
+  COMMIT_B = {'file': {'data': 'B'}}
+  COMMIT_H = {'file': {'data': 'H'}}
+  COMMIT_I = {'file': {'data': 'I'}}
+  COMMIT_J = {'file': {'data': 'J'}}
+  COMMIT_K = {'file': {'data': 'K'}}
+  COMMIT_L = {'file': {'data': 'L'}}
+
+  def setUp(self):
+    super(GitMutableStructuredTest, self).setUp()
+    self.repo.git('branch', '--set-upstream-to', 'root_X', 'branch_Z')
+    self.repo.git('branch', '--set-upstream-to', 'branch_G', 'branch_K')
+    self.repo.git('branch', '--set-upstream-to', 'branch_K', 'branch_L')
+    self.repo.git('branch', '--set-upstream-to', 'root_A', 'branch_G')
+    self.repo.git('branch', '--set-upstream-to', 'root_X', 'root_A')
+
+  def testMergeBase(self):
+    self.repo.git('checkout', 'branch_K')
+
+    self.assertEqual(
+      self.repo['B'],
+      self.repo.run(self.gc.get_or_create_merge_base, 'branch_K', 'branch_G')
+    )
+
+    self.assertEqual(
+      self.repo['J'],
+      self.repo.run(self.gc.get_or_create_merge_base, 'branch_L', 'branch_K')
+    )
+
+    self.assertEqual(
+      self.repo['B'], self.repo.run(self.gc.config, 'branch.branch_K.base')
+    )
+
+    # deadbeef is a bad hash, so this will result in repo['B']
+    self.repo.run(self.gc.manual_merge_base, 'branch_K', 'deadbeef')
+
+    self.assertEqual(
+      self.repo['B'],
+      self.repo.run(self.gc.get_or_create_merge_base, 'branch_K', 'branch_G')
+    )
+
+    # but if we pick a real ancestor, then it'll work
+    self.repo.run(self.gc.manual_merge_base, 'branch_K', self.repo['I'])
+
+    self.assertEqual(
+      self.repo['I'],
+      self.repo.run(self.gc.get_or_create_merge_base, 'branch_K', 'branch_G')
+    )
+
+    self.assertEqual({'branch_K': self.repo['I'], 'branch_L': self.repo['J']},
+                     self.repo.run(self.gc.branch_config_map, 'base'))
+
+    self.repo.run(self.gc.remove_merge_base, 'branch_K')
+    self.repo.run(self.gc.remove_merge_base, 'branch_L')
+
+    self.assertEqual(None,
+                     self.repo.run(self.gc.config, 'branch.branch_K.base'))
+
+    self.assertEqual({}, self.repo.run(self.gc.branch_config_map, 'base'))
+
+  def testGetBranchTree(self):
+    skipped, tree = self.repo.run(self.gc.get_branch_tree)
+    self.assertEqual(skipped, {'master', 'root_X'})
+    self.assertEqual(tree, {
+      'branch_G': 'root_A',
+      'root_A': 'root_X',
+      'branch_K': 'branch_G',
+      'branch_L': 'branch_K',
+      'branch_Z': 'root_X'
+    })
+
+    topdown = list(self.gc.topo_iter(tree))
+    bottomup = list(self.gc.topo_iter(tree, top_down=False))
+
+    self.assertEqual(topdown, [
+      ('branch_Z', 'root_X'),
+      ('root_A', 'root_X'),
+      ('branch_G', 'root_A'),
+      ('branch_K', 'branch_G'),
+      ('branch_L', 'branch_K'),
+    ])
+
+    self.assertEqual(bottomup, [
+      ('branch_L', 'branch_K'),
+      ('branch_Z', 'root_X'),
+      ('branch_K', 'branch_G'),
+      ('branch_G', 'root_A'),
+      ('root_A', 'root_X'),
+    ])
+
+  def testSquashBranch(self):
+    self.repo.git('checkout', 'branch_K')
+
+    self.repo.run(self.gc.squash_current_branch, 'cool message')
+
+    lines = ['cool message', '']
+    for l in 'HIJK':
+      lines.extend((self.repo[l], l, ''))
+    lines.pop()
+    msg = '\n'.join(lines)
+
+    self.assertEquals(self.repo.run(self.gc.run, 'log', '-n1', '--format=%B'),
+                      msg)
+
+    self.assertEquals(
+      self.repo.git('cat-file', 'blob', 'branch_K:file').stdout,
+      'K'
+    )
+
+  def testRebase(self):
+    self.assertSchema("""
+    A B C D E F G
+      B H I J K
+            J L
+
+    X Y Z
+    """)
+
+    rslt = self.repo.run(
+      self.gc.rebase, 'branch_G', 'branch_K~4', 'branch_K')
+    self.assertTrue(rslt.success)
+
+    self.assertSchema("""
+    A B C D E F G H I J K
+      B H I J L
+
+    X Y Z
+    """)
+
+    rslt = self.repo.run(
+      self.gc.rebase, 'branch_K', 'branch_L~1', 'branch_L', abort=True)
+    self.assertFalse(rslt.success)
+
+    self.assertFalse(self.repo.run(self.gc.in_rebase))
+
+    rslt = self.repo.run(
+      self.gc.rebase, 'branch_K', 'branch_L~1', 'branch_L', abort=False)
+    self.assertFalse(rslt.success)
+
+    self.assertTrue(self.repo.run(self.gc.in_rebase))
+
+    self.assertEqual(self.repo.git('status', '--porcelain').stdout, 'UU file\n')
+    self.repo.git('checkout', '--theirs', 'file')
+    self.repo.git('add', 'file')
+    self.repo.git('rebase', '--continue')
+
+    self.assertSchema("""
+    A B C D E F G H I J K L
+
+    X Y Z
+    """)
+
+
+class GitFreezeThaw(git_test_utils.GitRepoReadWriteTestBase):
+  @classmethod
+  def setUpClass(cls):
+    super(GitFreezeThaw, cls).setUpClass()
+    import git_common
+    cls.gc = git_common
+    cls.gc.TEST_MODE = True
+
+  REPO_SCHEMA = """
+  A B C D
+    B E D
+  """
+
+  COMMIT_A = {
+    'some/files/file1': {'data': 'file1'},
+    'some/files/file2': {'data': 'file2'},
+    'some/files/file3': {'data': 'file3'},
+    'some/other/file':  {'data': 'otherfile'},
+  }
+
+  COMMIT_C = {
+    'some/files/file2': {
+      'mode': 0755,
+      'data': 'file2 - vanilla'},
+  }
+
+  COMMIT_E = {
+    'some/files/file2': {'data': 'file2 - merged'},
+  }
+
+  COMMIT_D = {
+    'some/files/file2': {'data': 'file2 - vanilla\nfile2 - merged'},
+  }
+
+  def testNothing(self):
+    self.assertIsNotNone(self.repo.run(self.gc.thaw))  # 'Nothing to thaw'
+    self.assertIsNotNone(self.repo.run(self.gc.freeze))  # 'Nothing to freeze'
+
+  def testAll(self):
+    def inner():
+      with open('some/files/file2', 'a') as f2:
+        print >> f2, 'cool appended line'
+      os.mkdir('some/other_files')
+      with open('some/other_files/subdir_file', 'w') as f3:
+        print >> f3, 'new file!'
+      with open('some/files/file5', 'w') as f5:
+        print >> f5, 'New file!1!one!'
+
+      STATUS_1 = '\n'.join((
+        ' M some/files/file2',
+        'A  some/files/file5',
+        '?? some/other_files/'
+      )) + '\n'
+
+      self.repo.git('add', 'some/files/file5')
+
+      # Freeze group 1
+      self.assertEquals(self.repo.git('status', '--porcelain').stdout, STATUS_1)
+      self.assertIsNone(self.gc.freeze())
+      self.assertEquals(self.repo.git('status', '--porcelain').stdout, '')
+
+      # Freeze group 2
+      with open('some/files/file2', 'a') as f2:
+        print >> f2, 'new! appended line!'
+      self.assertEquals(self.repo.git('status', '--porcelain').stdout,
+                        ' M some/files/file2\n')
+      self.assertIsNone(self.gc.freeze())
+      self.assertEquals(self.repo.git('status', '--porcelain').stdout, '')
+
+      # Thaw it out!
+      self.assertIsNone(self.gc.thaw())
+      self.assertIsNotNone(self.gc.thaw())  # One thaw should thaw everything
+
+      self.assertEquals(self.repo.git('status', '--porcelain').stdout, STATUS_1)
+
+    self.repo.run(inner)
+
+
 if __name__ == '__main__':
   sys.exit(coverage_utils.covered_main(
     os.path.join(DEPOT_TOOLS_ROOT, 'git_common.py')