Handle branch or commit refs in the url for unmanaged git solutions

tests/gclient_scm_test.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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 gclient_scm.py."""
 
 # pylint: disable=E1103
 
 # Import before super_mox to keep valid references.
@@ skipping 873 matching lines @@
   def _GetAskForDataCallback(self, expected_prompt, return_value):
     def AskForData(prompt, options):
       self.assertEquals(prompt, expected_prompt)
       return return_value
     return AskForData
 
   def setUp(self):
     TestCaseUtils.setUp(self)
     unittest.TestCase.setUp(self)
     self.url = 'git://foo'
-    self.root_dir = tempfile.mkdtemp()
+    # The .git suffix allows gclient_scm to recognize the dir as a git repo
+    # when cloning it locally
+    self.root_dir = tempfile.mkdtemp('.git')
     self.relpath = '.'
     self.base_path = join(self.root_dir, self.relpath)
     self.enabled = self.CreateGitRepo(self.sample_git_import, self.base_path)
     StdoutCheck.setUp(self)
     self._original_GitBinaryExists = gclient_scm.GitWrapper.BinaryExists
     self._original_SVNBinaryExists = gclient_scm.SVNWrapper.BinaryExists
     gclient_scm.GitWrapper.BinaryExists = staticmethod(lambda : True)
     gclient_scm.SVNWrapper.BinaryExists = staticmethod(lambda : True)
 
   def tearDown(self):
@@ skipping 465 matching lines @@
         ).AndReturn('')
 
     self.mox.ReplayAll()
     scm = self._scm_wrapper(url=self.url, root_dir=self.root_dir,
                             relpath=self.relpath)
     scm.update(options, None, [])
     self.checkstdout('\n')
 
 
 class UnmanagedGitWrapperTestCase(BaseGitWrapperTestCase):
+  def checkInStdout(self, expected):
+    value = sys.stdout.getvalue()
+    sys.stdout.close()
+    # pylint: disable=E1101
+    self.assertIn(expected, value)
+
+  def checkNotInStdout(self, expected):
+    value = sys.stdout.getvalue()
+    sys.stdout.close()
+    # pylint: disable=E1101
+    self.assertNotIn(expected, value)
+
+  def getCurrentBranch(self):
+    # Returns name of current branch or HEAD for detached HEAD
+    branch = gclient_scm.scm.GIT.Capture(['rev-parse', '--abbrev-ref', 'HEAD'],
+                                          cwd=self.base_path)
+    if branch == 'HEAD':
+      return None
+    return branch
+
+  def testUpdateClone(self):
+    if not self.enabled:
+      return
+    options = self.Options()
+
+    origin_root_dir = self.root_dir
+    self.root_dir = tempfile.mkdtemp()
+    self.relpath = '.'
+    self.base_path = join(self.root_dir, self.relpath)
+
+    scm = gclient_scm.CreateSCM(url=origin_root_dir,
+                                root_dir=self.root_dir,
+                                relpath=self.relpath)
+
+    expected_file_list = [join(self.base_path, "a"),
+                          join(self.base_path, "b")]
+    file_list = []
+    options.revision = 'unmanaged'
+    scm.update(options, (), file_list)
+
+    self.assertEquals(file_list, expected_file_list)
+    self.assertEquals(scm.revinfo(options, (), None),
+                      '069c602044c5388d2d15c3f875b057c852003458')
+    # indicates detached HEAD
+    self.assertEquals(self.getCurrentBranch(), None)
+    self.checkInStdout(
+      'Checked out refs/remotes/origin/master to a detached HEAD')
+
+    rmtree(origin_root_dir)
+
+  def testUpdateCloneOnCommit(self):
+    if not self.enabled:
+      return
+    options = self.Options()
+
+    origin_root_dir = self.root_dir
+    self.root_dir = tempfile.mkdtemp()
+    self.relpath = '.'
+    self.base_path = join(self.root_dir, self.relpath)
+    url_with_commit_ref = origin_root_dir +\
+                          '@a7142dc9f0009350b96a11f372b6ea658592aa95'
+
+    scm = gclient_scm.CreateSCM(url=url_with_commit_ref,
+                                root_dir=self.root_dir,
+                                relpath=self.relpath)
+
+    expected_file_list = [join(self.base_path, "a"),
+                          join(self.base_path, "b")]
+    file_list = []
+    options.revision = 'unmanaged'
+    scm.update(options, (), file_list)
+
+    self.assertEquals(file_list, expected_file_list)
+    self.assertEquals(scm.revinfo(options, (), None),
+                      'a7142dc9f0009350b96a11f372b6ea658592aa95')
+    # indicates detached HEAD
+    self.assertEquals(self.getCurrentBranch(), None)
+    self.checkInStdout(
+      'Checked out a7142dc9f0009350b96a11f372b6ea658592aa95 to a detached HEAD')
+
+    rmtree(origin_root_dir)
+
+  def testUpdateCloneOnBranch(self):
+    if not self.enabled:
+      return
+    options = self.Options()
+
+    origin_root_dir = self.root_dir
+    self.root_dir = tempfile.mkdtemp()
+    self.relpath = '.'
+    self.base_path = join(self.root_dir, self.relpath)
+    url_with_branch_ref = origin_root_dir + '@feature'
+
+    scm = gclient_scm.CreateSCM(url=url_with_branch_ref,
+                                root_dir=self.root_dir,
+                                relpath=self.relpath)
+
+    expected_file_list = [join(self.base_path, "a"),
+                          join(self.base_path, "b"),
+                          join(self.base_path, "c")]
+    file_list = []
+    options.revision = 'unmanaged'
+    scm.update(options, (), file_list)
+
+    self.assertEquals(file_list, expected_file_list)
+    self.assertEquals(scm.revinfo(options, (), None),
+                      '9a51244740b25fa2ded5252ca00a3178d3f665a9')
+    self.assertEquals(self.getCurrentBranch(), 'feature')
+    self.checkNotInStdout('Checked out feature to a detached HEAD')
+
+    rmtree(origin_root_dir)
+
+  def testUpdateCloneOnDetachedBranch(self):
+    if not self.enabled:
+      return
+    options = self.Options()
+
+    origin_root_dir = self.root_dir
+    self.root_dir = tempfile.mkdtemp()
+    self.relpath = '.'
+    self.base_path = join(self.root_dir, self.relpath)
+    url_with_branch_ref = origin_root_dir + '@refs/remotes/origin/feature'
+
+    scm = gclient_scm.CreateSCM(url=url_with_branch_ref,
+                                root_dir=self.root_dir,
+                                relpath=self.relpath)
+
+    expected_file_list = [join(self.base_path, "a"),
+                          join(self.base_path, "b"),
+                          join(self.base_path, "c")]
+    file_list = []
+    options.revision = 'unmanaged'
+    scm.update(options, (), file_list)
+
+    self.assertEquals(file_list, expected_file_list)
+    self.assertEquals(scm.revinfo(options, (), None),
+                      '9a51244740b25fa2ded5252ca00a3178d3f665a9')
+    # indicates detached HEAD
+    self.assertEquals(self.getCurrentBranch(), None)
+    self.checkInStdout(
+      'Checked out refs/remotes/origin/feature to a detached HEAD')
+
+    rmtree(origin_root_dir)
+
+  def testUpdateCloneOnBranchHead(self):

[Michael Moss, 2014/09/08 20:24:01]

(Dredging up this old CL because this test is causing a failure in some code I'm
trying to add)

I don't understand the intended difference between testUpdateCloneOnBranchHead()
and testUpdateCloneOnDetachedBranch(). It looks like you expect
@refs/remotes/origin/feature to behave differently from @refs/heads/feature, but
I'm not sure why. I assume they are both meant to refer to the 'feature' branch
in the remote repo, but one is specified from the POV of the mirror
(refs/remotes/origin) and one is specified from the POV of the original
(refs/heads/). Why do you expect or want gclient to check this out detached in
one instance, but not detached in the other? I think synonyms for the same
remote should be checked out in the same way (or just treated as the same thing
in general, which is what my code tries to do).

If your intent is that 'refs/heads/feature' doesn't actually refer to the
remote, but rather to a local branch (hopefully based on that remote), well, I'm
not sure specifying local branches is something that really makes sense for DEPS
files.

+    if not self.enabled:
+      return
+    options = self.Options()
+
+    origin_root_dir = self.root_dir
+    self.root_dir = tempfile.mkdtemp()
+    self.relpath = '.'
+    self.base_path = join(self.root_dir, self.relpath)
+    url_with_branch_ref = origin_root_dir + '@refs/heads/feature'
+
+    scm = gclient_scm.CreateSCM(url=url_with_branch_ref,
+                                root_dir=self.root_dir,
+                                relpath=self.relpath)
+
+    expected_file_list = [join(self.base_path, "a"),
+                          join(self.base_path, "b"),
+                          join(self.base_path, "c")]
+    file_list = []
+    options.revision = 'unmanaged'
+    scm.update(options, (), file_list)
+
+    self.assertEquals(file_list, expected_file_list)
+    self.assertEquals(scm.revinfo(options, (), None),
+                      '9a51244740b25fa2ded5252ca00a3178d3f665a9')
+    self.assertEquals(self.getCurrentBranch(), 'feature')
+    self.checkNotInStdout(
+      'Checked out refs/heads/feature to a detached HEAD')
+
+    rmtree(origin_root_dir)
+
   def testUpdateUpdate(self):
     if not self.enabled:
       return
     options = self.Options()
     expected_file_list = []
     scm = gclient_scm.CreateSCM(url=self.url, root_dir=self.root_dir,
                                 relpath=self.relpath)
     file_list = []
     options.revision = 'unmanaged'
     scm.update(options, (), file_list)
     self.assertEquals(file_list, expected_file_list)
     self.assertEquals(scm.revinfo(options, (), None),
                       '069c602044c5388d2d15c3f875b057c852003458')
     self.checkstdout('________ unmanaged solution; skipping .\n')
 
 
 if __name__ == '__main__':
   if '-v' in sys.argv:
     logging.basicConfig(
         level=logging.DEBUG,
         format='%(asctime).19s %(levelname)s %(filename)s:'
                '%(lineno)s %(message)s')
   unittest.main()
 
 # vim: ts=2:sw=2:tw=80:et: