Make marked merge base invalid when the upstream changes.

tests/git_common_test.py

 #!/usr/bin/env python
 # Copyright 2013 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 git_common.py"""
 
 import binascii
 import collections
 import os
@@ skipping 357 matching lines @@
 
 
 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
+
+  CAT DOG
   """
 
   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 testTooManyBranches(self):
     for i in xrange(30):
       self.repo.git('branch', 'a'*i)
 
-    with self.assertRaises(SystemExit):
-      self.repo.run(list, self.gc.branches())
+    _, rslt = self.repo.capture_stdio(list, self.gc.branches())
+    self.assertIn('too many branches (39/20)', rslt)

[iannucci, 2014/05/15 22:20:17]

these were printing output during the test execution, so changed to
'capture_stdio'

 
     self.repo.git('config', 'depot-tools.branch-limit', 'cat')
 
-    with self.assertRaises(SystemExit):
-      self.repo.run(list, self.gc.branches())
+    _, rslt = self.repo.capture_stdio(list, self.gc.branches())
+    self.assertIn('too many branches (39/20)', rslt)
 
     self.repo.git('config', 'depot-tools.branch-limit', '100')
 
     # should not raise
-    self.assertEqual(36, len(self.repo.run(list, self.gc.branches())))
+    self.assertEqual(38, len(self.repo.run(list, self.gc.branches())))
 
   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')
     )
+    self.assertEqual(
+      'branch_G', self.repo.run(self.gc.config, 'branch.branch_K.base-upstream')
+    )
 
     # deadbeef is a bad hash, so this will result in repo['B']
-    self.repo.run(self.gc.manual_merge_base, 'branch_K', 'deadbeef')
+    self.repo.run(self.gc.manual_merge_base, 'branch_K', 'deadbeef', 'branch_G')
 
     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.repo.run(self.gc.manual_merge_base, 'branch_K', self.repo['I'],
+                  'branch_G')
 
     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'))
 
     # if it's too old, then it caps at merge-base
-    self.repo.run(self.gc.manual_merge_base, 'branch_K', self.repo['A'])
+    self.repo.run(self.gc.manual_merge_base, 'branch_K', self.repo['A'],
+                  'branch_G')
 
     self.assertEqual(
       self.repo['B'],
       self.repo.run(self.gc.get_or_create_merge_base, 'branch_K', 'branch_G')
     )
 
+    # If the user does --set-upstream-to something else, then we discard the
+    # base and recompute it.
+    self.repo.run(self.gc.run, 'branch', '-u', 'root_A')
+    self.assertEqual(
+      self.repo['A'],
+      self.repo.run(self.gc.get_or_create_merge_base, 'branch_K')
+    )
+
+    self.assertIsNone(
+      self.repo.run(self.gc.get_or_create_merge_base, 'branch_DOG'))
+
   def testGetBranchTree(self):
     skipped, tree = self.repo.run(self.gc.get_branch_tree)
-    self.assertEqual(skipped, {'master', 'root_X'})
+    self.assertEqual(skipped, {'master', 'root_X', 'branch_DOG', 'root_CAT'})
     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))
@@ skipping 33 matching lines @@
       'K'
     )
 
   def testRebase(self):
     self.assertSchema("""
     A B C D E F G
       B H I J K
             J L
 
     X Y Z
+
+    CAT DOG
     """)
 
     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
+
+    CAT DOG
     """)
 
     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
+
+    CAT DOG
     """)
 
 
 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
@@ skipping 65 matching lines @@
 
       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')
   ))