llvm push: Print remote branch name after pushing

Get llvm.py push to print the name of the remote branch that it has
pushed to. This is helpful so developers don't need to guess what
namespaces have been prepended to the branch name, and also serves as
quick visual confirmation.

This required a bit of refactoring, since the name of the branch was
computed when needed. We now compute it separately and pass it in to the
function that pushes the branch. We rely on the fact that the branch
name will be the same for all the subprojects involved.

Most of the changes are mechanical, to account for this refactoring
(including new names for some of the existing functions, which make more
sense in this new context).

Change-Id: Id7e496bcded60080803e3a850d73329428bc3bac

1 files changed, 111 insertions, 79 deletions

diff --git a/tests/unittests/testpush.py b/tests/unittests/testpush.py
index 0046e2b..3eb8e35 100644
--- a/tests/unittests/testpush.py
+++ b/tests/unittests/testpush.py
@@ -9,7 +9,30 @@ from linaropy.proj import Proj
 from linaropy.git.clone import Clone
 from linaropy.git.worktree import Worktree
 
-from modules.llvm import get_user_from_remote, push_current_branch
+from modules.llvm import get_user_from_remote, get_remote_branch, push_branch
+
+# FIXME: Maybe move these helpers somewhere more public, or use LLVMTestCase for
+# these tests as well...
+
+
+def create_dummy_commit(message="Branches without commits confuse git"):
+    filename = "file" + str(uuid.uuid4())
+    open(filename, "a").close()
+    git("add", filename)
+    git("commit", "-m", message)
+
+
+def get_last_commit_message(branch=""):
+    return str(git("rev-list", "-1", "--oneline", branch)).strip()
+
+
+def create_dummy_repo(path):
+    if not os.path.exists(path):
+        os.makedirs(path)
+
+    with cd(path):
+        git("init")
+        create_dummy_commit()
 
 
 class TestGetUser(unittest.TestCase):
@@ -31,27 +54,69 @@ class TestGetUser(unittest.TestCase):
         self.assertEqual(user, None)
 
 
-class TestPush(unittest.TestCase):
-    testdirprefix = "PushUT"
+class TestGetRemoteBranch(unittest.TestCase):
+    testdirprefix = "GetRemoteBranchUT"
+
+    def setUp(self):
+        # Create a git repo so we can play with its remotes.
+        self.proj = Proj(prefix=self.testdirprefix)
+
+        path = os.path.join(self.proj.projdir, "repo")
+        create_dummy_repo(path)
+        self.repo = Clone(self.proj, path)
+
+    def tearDown(self):
+        self.proj.cleanup()
+
+    def test_valid_branch(self):
+        """
+        Test that we return the correct remote branch name if everything is
+        valid.
+        """
+        user = "a.user"
+        remote = "file://{}@{}".format(user, self.repo.repodir)
+        with cd(self.repo.repodir):
+            git("remote", "add", "origin", remote)
+
+        local_branch = "a-branch"
+        remote_branch = get_remote_branch(self.repo, local_branch)
+        self.assertEqual(
+            remote_branch, "linaro-local/{}/{}".format(user, local_branch))
+
+    def test_no_user(self):
+        """Test that we error out when we can't parse a user in the remote name."""
+        remote = "file://" + self.repo.repodir
+        with cd(self.repo.repodir):
+            git("remote", "add", "origin", remote)
+
+        with self.assertRaises(EnvironmentError) as context:
+            get_remote_branch(self.repo, "a-branch")
+
+        self.assertEqual(str(context.exception),
+                         "Couldn't parse user from {}.".format(remote))
+
+    def test_invalid_user(self):
+        """
+        Test that we error out when the value of the user parsed from the remote
+        wouldn't look good in a branch name (e.g. if it contains spaces).
+        """
+
+        badUser = "LLVM Developer"
+        with cd(self.repo.repodir):
+            git("remote", "add", "origin",
+                "file://{}@{}".format(badUser, self.repo.repodir))
 
-    def __create_dummy_commit(
-            self,
-            message="Branches without commits confuse git"):
-        filename = "file" + str(uuid.uuid4())
-        open(filename, "a").close()
-        git("add", filename)
-        git("commit", "-m", message)
+        branch = "a-branch"
+        with self.assertRaises(EnvironmentError) as context:
+            get_remote_branch(self.repo, branch)
 
-    def __get_last_commit_message(self, branch=""):
-        return str(git("rev-list", "-1", "--oneline", branch)).strip()
+        self.assertEqual(str(context.exception),
+                         "linaro-local/{}/{} is not a valid branch name.".format(badUser,
+                                                                                 branch))
 
-    def __create_dummy_repo(self, path):
-        if not os.path.exists(path):
-            os.makedirs(path)
 
-        with cd(path):
-            git("init")
-            self.__create_dummy_commit()
+class TestPushBranch(unittest.TestCase):
+    testdirprefix = "PushBranchUT"
 
     def setUp(self):
         # We're going to create a hierarchy with an origin repo, a clone repo
@@ -61,7 +126,7 @@ class TestPush(unittest.TestCase):
         self.user = "llvm-developer"
 
         path = os.path.join(self.proj.projdir, "origin")
-        self.__create_dummy_repo(path)
+        create_dummy_repo(path)
         self.origin = Clone(self.proj, path)
 
         path = os.path.join(self.proj.projdir, "clone")
@@ -69,6 +134,7 @@ class TestPush(unittest.TestCase):
         self.clone = Clone(self.proj, path)
 
         self.worktreeBranch = "a-branch"
+        self.remoteBranch = "remotely/a-branch"
         self.worktree = Worktree.create(
             self.proj, self.clone, os.path.join(
                 self.proj.projdir, "worktree"), self.worktreeBranch)
@@ -80,35 +146,30 @@ class TestPush(unittest.TestCase):
         """Test that we can push a new branch to origin."""
 
         with cd(self.worktree.repodir):
-            self.__create_dummy_commit("This should make it to origin")
+            create_dummy_commit("This should make it to origin")
 
-        push_current_branch(self.proj, self.worktree.repodir)
+        push_branch(self.proj, self.worktreeBranch, self.remoteBranch,
+                    self.worktree.repodir)
 
         with cd(self.origin.repodir):
             self.assertRegex(
-                self.__get_last_commit_message(
-                    "linaro-local/{}/{}".format(
-                        self.user,
-                        self.worktreeBranch)),
+                get_last_commit_message(self.remoteBranch),
                 ".*This should make it to origin")
 
     def test_push_existing_branch(self):
         """Test that we can push to a branch that already exists in origin."""
-
-        remoteBranch = "linaro-local/{}/{}".format(
-            self.user, self.worktreeBranch)
-
         with cd(self.worktree.repodir):
-            self.__create_dummy_commit("This already exists in origin")
+            create_dummy_commit("This already exists in origin")
             git("push", "origin", "{}:{}".format(
-                self.worktreeBranch, remoteBranch))
+                self.worktreeBranch, self.remoteBranch))
 
-            self.__create_dummy_commit("This should make it to origin too")
+            create_dummy_commit("This should make it to origin too")
 
-        push_current_branch(self.proj, self.worktree.repodir)
+        push_branch(self.proj, self.worktreeBranch, self.remoteBranch,
+                    self.worktree.repodir)
 
         with cd(self.origin.repodir):
-            self.assertRegex(self.__get_last_commit_message(remoteBranch),
+            self.assertRegex(get_last_commit_message(self.remoteBranch),
                              ".*This should make it to origin too")
 
     def test_push_squashed_update(self):
@@ -117,84 +178,55 @@ class TestPush(unittest.TestCase):
         that has already been pushed to origin. This isn't a nice thing to do,
         but we need to support it because Gerrit requires squashes.
         """
-        remoteBranch = "linaro-local/{}/{}".format(self.user,
-                                                   self.worktreeBranch)
         with cd(self.worktree.repodir):
-            self.__create_dummy_commit("First version of the patch")
+            create_dummy_commit("First version of the patch")
 
-        push_current_branch(self.proj, self.worktree.repodir)
+        push_branch(self.proj, self.worktreeBranch, self.remoteBranch,
+                    self.worktree.repodir)
 
         with cd(self.origin.repodir):
             self.assertRegex(
-                self.__get_last_commit_message(remoteBranch),
+                get_last_commit_message(self.remoteBranch),
                 ".*First version of the patch")
 
         with cd(self.worktree.repodir):
             git("commit", "--amend", "-m", "Second version of the patch")
 
-        push_current_branch(self.proj, self.worktree.repodir)
+        push_branch(self.proj, self.worktreeBranch, self.remoteBranch,
+                    self.worktree.repodir)
 
         with cd(self.origin.repodir):
             self.assertRegex(
-                self.__get_last_commit_message(remoteBranch),
+                get_last_commit_message(self.remoteBranch),
                 "/*Second version of the patch")
 
     def test_push_rebased_branch(self):
         """ Test that we can push again with new updates after a rebase."""
-        remoteBranch = "linaro-local/{}/{}".format(self.user,
-                                                   self.worktreeBranch)
         with cd(self.worktree.repodir):
-            self.__create_dummy_commit("First change")
+            create_dummy_commit("First change")
 
-        push_current_branch(self.proj, self.worktree.repodir)
+        push_branch(self.proj, self.worktreeBranch, self.remoteBranch,
+                    self.worktree.repodir)
 
         with cd(self.origin.repodir):
             self.assertRegex(
-                self.__get_last_commit_message(remoteBranch),
+                get_last_commit_message(self.remoteBranch),
                 ".*First change")
 
         with cd(self.origin.repodir):
-            self.__create_dummy_commit("Master moving forward")
+            create_dummy_commit("Master moving forward")
 
         with cd(self.worktree.repodir):
-            self.__create_dummy_commit("Second change")
+            create_dummy_commit("Second change")
             git("fetch", "origin", "master")
             git("rebase", "origin/master")
 
-        push_current_branch(self.proj, self.worktree.repodir)
+        push_branch(self.proj, self.worktreeBranch, self.remoteBranch,
+                    self.worktree.repodir)
 
         with cd(self.origin.repodir):
-            self.assertRegex(self.__get_last_commit_message(remoteBranch),
+            self.assertRegex(get_last_commit_message(self.remoteBranch),
                              ".*Second change")
 
-    def test_push_no_user(self):
-        """Test that we error out when we can't parse a user in the remote name."""
-        remote = "file://" + self.origin.repodir
-        with cd(self.worktree.repodir):
-            git("remote", "set-url", "origin", remote)
-            self.__create_dummy_commit("Make it look like a real branch")
-
-        with self.assertRaises(EnvironmentError) as context:
-            push_current_branch(self.proj, self.worktree.repodir)
-
-        self.assertEqual(str(context.exception),
-                         "Couldn't parse user from {}.".format(remote))
-
-    def test_push_invalid_user(self):
-        """Test that we error out when the value of LLVM_GITUSER wouldn't look good in a branch name (e.g. if it contains spaces)."""
-
-        badUser = "LLVM Developer"
-        with cd(self.worktree.repodir):
-            git("remote", "set-url", "origin",
-                "file://{}@{}".format(badUser, self.origin.repodir))
-            self.__create_dummy_commit("Make it look like a real branch")
-
-        with self.assertRaises(EnvironmentError) as context:
-            push_current_branch(self.proj, self.worktree.repodir)
-
-        self.assertEqual(str(context.exception),
-                         "linaro-local/{}/{} is not a valid branch name.".format(badUser,
-                                                                                 self.worktreeBranch))
-
 if __name__ == "__main__":
     unittest.main()