Fix "git rebase-update" when multiple branch are stale.

tests/git_rebase_update_test.py

 #!/usr/bin/env python
 # Copyright 2014 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_rebase_update.py"""
 
 import os
 import sys
 
@@ skipping 50 matching lines @@
     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', 'origin/master', 'branch_G')
 
     self.repo.to_schema_refs += ['origin/master']
 
   def tearDown(self):
     self.origin.nuke()
     super(GitRebaseUpdateTest, self).tearDown()
 
   def testRebaseUpdate(self):

[iannucci, 2015/12/02 18:08:51]

I've created a monster (unit test)!

I think I'm going to have to break this up later... it's getting pretty
silly-long :)

[sdefresne, 2015/12/02 18:12:53]

:-) BTW, those tests are not independent (i.e. running just "testRebaseUpdate"
fails), but this pre-existed my CL:

$ tests/git_rebase_update_test.py GitRebaseUpdateTest.testRebaseUpdate
Switched to branch foobar.
Switched to branch int1_foobar.
Switched to branch int2_foobar.
Switched to branch sub_foobar.
Switched to branch sub_K.
Switched to branch old_branch.
F
======================================================================
FAIL: testRebaseUpdate (__main__.GitRebaseUpdateTest)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "tests/git_rebase_update_test.py", line 125, in testRebaseUpdate
    self.assertIn('Cannot rebase-update', output)
AssertionError: 'Cannot rebase-update' not found in ''

----------------------------------------------------------------------
Ran 1 test in 2.072s

FAILED (failures=1)
Name                  Stmts   Miss  Cover   Missing
---------------------------------------------------
git_new_branch           28      7    75%   37-40, 46-49
git_rebase_update       174    152    13%   34-43, 48-82, 87-137, 141-215,
238-320
git_rename_branch        29     22    24%   17-47
git_reparent_branch      45     37    18%   19-74
---------------------------------------------------
TOTAL                   276    218    21%   
FATAL: not at required 100.000000% coverage.

     self.repo.git('checkout', 'branch_K')
 
     self.repo.run(self.nb.main, ['foobar'])
     self.assertEqual(self.repo.git('rev-parse', 'HEAD').stdout,
                      self.repo.git('rev-parse', 'origin/master').stdout)
 
     with self.repo.open('foobar', 'w') as f:
       f.write('this is the foobar file')
     self.repo.git('add', 'foobar')
     self.repo.git_commit('foobar1')
 
     with self.repo.open('foobar', 'w') as f:
       f.write('totes the Foobar file')
     self.repo.git_commit('foobar2')
 
+    self.repo.run(self.nb.main, ['--upstream-current', 'int1_foobar'])
+    self.repo.run(self.nb.main, ['--upstream-current', 'int2_foobar'])
+    self.repo.run(self.nb.main, ['--upstream-current', 'sub_foobar'])
+    with self.repo.open('foobar', 'w') as f:
+        f.write('some more foobaring')
+    self.repo.git('add', 'foobar')
+    self.repo.git_commit('foobar3')
+
     self.repo.git('checkout', 'branch_K')
     self.repo.run(self.nb.main, ['--upstream-current', 'sub_K'])
     with self.repo.open('K', 'w') as f:
       f.write('This depends on K')
     self.repo.git_commit('sub_K')
 
     self.repo.run(self.nb.main, ['old_branch'])
     self.repo.git('reset', '--hard', self.repo['A'])
     with self.repo.open('old_file', 'w') as f:
       f.write('old_files we want to keep around')
     self.repo.git('add', 'old_file')
     self.repo.git_commit('old_file')
     self.repo.git('config', 'branch.old_branch.dormant', 'true')
 
     self.repo.git('checkout', 'origin/master')
 
     self.assertSchema("""
     A B H I J K sub_K
             J L
-      B C D E foobar1 foobar2
+      B C D E foobar1 foobar2 foobar3
             E F G
     A old_file
     """)
     self.assertEquals(self.repo['A'], self.origin['A'])
     self.assertEquals(self.repo['E'], self.origin['E'])
 
     with self.repo.open('bob', 'wb') as f:
       f.write('testing auto-freeze/thaw')
 
     output, _ = self.repo.capture_stdio(self.reup.main)
     self.assertIn('Cannot rebase-update', output)
 
     self.repo.run(self.nb.main, ['empty_branch'])
     self.repo.run(self.nb.main, ['--upstream-current', 'empty_branch2'])
 
     self.repo.git('checkout', 'branch_K')
 
     output, _ = self.repo.capture_stdio(self.reup.main)
 
     self.assertIn('Rebasing: branch_G', output)
     self.assertIn('Rebasing: branch_K', output)
     self.assertIn('Rebasing: branch_L', output)
     self.assertIn('Rebasing: foobar', output)
     self.assertIn('Rebasing: sub_K', output)
     self.assertIn('Deleted branch branch_G', output)
     self.assertIn('Deleted branch empty_branch', output)
     self.assertIn('Deleted branch empty_branch2', output)
+    self.assertIn('Deleted branch int1_foobar', output)
+    self.assertIn('Deleted branch int2_foobar', output)
     self.assertIn('Reparented branch_K to track origin/master', output)
+    self.assertIn('Reparented sub_foobar to track foobar', output)
 
     self.assertSchema("""
     A B C D E F G M N O H I J K sub_K
                               K L
-                      O foobar1 foobar2
+                      O foobar1 foobar2 foobar3
     A old_file
     """)
 
     output, _ = self.repo.capture_stdio(self.reup.main)
     self.assertIn('branch_K up-to-date', output)
     self.assertIn('branch_L up-to-date', output)
     self.assertIn('foobar up-to-date', output)
     self.assertIn('sub_K up-to-date', output)
 
     with self.repo.open('bob') as f:
@@ skipping 10 matching lines @@
     self.repo.git('checkout', 'branch_K')
     _, err = self.repo.capture_stdio(self.rp.main, ['origin/master'])
     self.assertIn('Cannot reparent a branch to its existing parent', err)
     output, _ = self.repo.capture_stdio(self.rp.main, ['foobar'])
     self.assertIn('Rebasing: branch_K', output)
     self.assertIn('Rebasing: sub_K', output)
     self.assertIn('Rebasing: branch_L', output)
 
     self.assertSchema("""
     A B C D E F G M N O foobar1 foobar2 H I J K L
+                                foobar2 foobar3
                                               K sub_K
     A old_file
     """)
 
     self.repo.git('checkout', 'sub_K')
     output, _ = self.repo.capture_stdio(self.rp.main, ['foobar'])
     self.assertIn('Squashing failed', output)
 
     self.assertTrue(self.repo.run(self.gc.in_rebase))
 
     self.repo.git('rebase', '--abort')
     self.assertIsNone(self.repo.run(self.gc.thaw))
 
     self.assertSchema("""
     A B C D E F G M N O foobar1 foobar2 H I J K L
+                                foobar2 foobar3
     A old_file
                                               K sub_K
     """)
 
     self.assertEqual(self.repo.git('status', '--porcelain').stdout, '?? bob\n')
 
     branches = self.repo.run(set, self.gc.branches())
     self.assertEqual(branches, {'branch_K', 'master', 'sub_K', 'root_A',
-                                'branch_L', 'old_branch', 'foobar'})
+                                'branch_L', 'old_branch', 'foobar',
+                                'sub_foobar'})
 
     self.repo.git('checkout', 'branch_K')
     self.repo.run(self.mv.main, ['special_K'])
 
     branches = self.repo.run(set, self.gc.branches())
     self.assertEqual(branches, {'special_K', 'master', 'sub_K', 'root_A',
-                                'branch_L', 'old_branch', 'foobar'})
+                                'branch_L', 'old_branch', 'foobar',
+                                'sub_foobar'})
 
     self.repo.git('checkout', 'origin/master')
     _, err = self.repo.capture_stdio(self.mv.main, ['special_K', 'cool branch'])
     self.assertIn('fatal: \'cool branch\' is not a valid branch name.', err)
 
     self.repo.run(self.mv.main, ['special_K', 'cool_branch'])
     branches = self.repo.run(set, self.gc.branches())
     # This check fails with git 2.4 (see crbug.com/487172)
     self.assertEqual(branches, {'cool_branch', 'master', 'sub_K', 'root_A',
-                                'branch_L', 'old_branch', 'foobar'})
+                                'branch_L', 'old_branch', 'foobar',
+                                'sub_foobar'})
 
     _, branch_tree = self.repo.run(self.gc.get_branch_tree)
     self.assertEqual(branch_tree['sub_K'], 'foobar')
 
 
   def testRebaseConflicts(self):
     # Pretend that branch_L landed
     self.origin.git('checkout', 'master')
     with self.origin.open('L', 'w') as f:
       f.write('L')
@@ skipping 151 matching lines @@
     """)
 
 
 if __name__ == '__main__':
   sys.exit(coverage_utils.covered_main((
     os.path.join(DEPOT_TOOLS_ROOT, 'git_rebase_update.py'),
     os.path.join(DEPOT_TOOLS_ROOT, 'git_new_branch.py'),
     os.path.join(DEPOT_TOOLS_ROOT, 'git_reparent_branch.py'),
     os.path.join(DEPOT_TOOLS_ROOT, 'git_rename_branch.py')
   )))