Add convenience method for creating a branch

Author: jpichon

git_wrapper/branch.py

@@ -48,6 +48,27 @@ def _run_cherry(self, upstream, head, regex):
                 ret_data[match.group(1)] = match.group(2)
         return ret_data
 
+    @reference_exists("start_ref")
+    def create(self, name, start_ref, reset_if_exists=False):
+        """Create a local branch based on start_ref.
+
+           If the branch exists, do nothing or hard reset it if reset_if_exists
+           is set.
+
+           :param str name: New branch's name
+           :param str start_ref: Reference (branch, commit, tag, ...) to use as
+                                 a starting point.
+           :param bool reset_if_exists: Whether to hard reset the branch to
+                                        start_ref if the branch already exists.
+        """
+        if not self.exists(name):
+            self.git_repo.git.branch(name, start_ref)
+            return True
+        if self.exists(name) and not reset_if_exists:
+            return
+        if self.exists(name) and reset_if_exists:
+            self.hard_reset_to_ref(name, start_ref)
+
     def exists(self, name, remote=None):
         """Checks if a branch exists locally or on the specified remote.
 
@@ -279,7 +300,7 @@ def short_log_diff(self, hash_from, hash_to):
 
     def hard_reset(self, branch="master", remote="origin",
                    remote_branch="master", refresh=True):
-        """Perform a hard reset of a local branch.
+        """Perform a hard reset of a local branch to a remote branch.
 
            :param str branch: Local branch to reset
            :param str remote: Remote use as base for the reset
@@ -289,7 +310,23 @@ def hard_reset(self, branch="master", remote="origin",
         if refresh:
             self.git_repo.remote.fetch(remote)
 
-        # Switch to branch
+        remote_ref = "{0}/{1}".format(remote, remote_branch)
+        self.hard_reset_to_ref(branch, remote_ref)
+
+    def hard_reset_to_ref(self, branch, ref):
+        """Perform a hard reset of a local branch to any reference.
+
+           :param str branch: Local branch to reset
+           :param str ref: Reference (commit, tag, ...) to reset to
+        """
+        # Ensure the reference maps to a commit
+        try:
+            commit = git.repo.fun.name_to_object(self.git_repo.repo, ref)
+        except git.exc.BadName as ex:
+            msg = "Could not find reference {0}.".format(ref)
+            raise_from(exceptions.ReferenceNotFoundException(msg), ex)
+
+        # Switch to the branch
         try:
             self.git_repo.git.checkout(branch)
         except git.GitCommandError as ex:
@@ -299,25 +336,14 @@ def hard_reset(self, branch="master", remote="origin",
             )
             raise_from(exceptions.CheckoutException(msg), ex)
 
-        # Get a reference to the commit we want to reset to
-        remote_ref = "{0}/{1}".format(remote, remote_branch)
-        try:
-            commit = git.repo.fun.name_to_object(self.git_repo.repo,
-                                                 remote_ref)
-        except git.exc.BadName as ex:
-            msg = "Could not find remote reference {0}.".format(remote_ref)
-            raise_from(exceptions.ReferenceNotFoundException(msg), ex)
-
         # Reset --hard to that reference
         try:
             self.git_repo.repo.head.reset(commit=commit,
                                           index=True,
                                           working_tree=True)
         except git.GitCommandError as ex:
             msg = (
-                "Error resetting branch {branch} to {remote_ref}. "
-                "Error: {error}".format(remote_ref=remote_ref,
-                                        branch=branch,
-                                        error=ex)
+                "Error resetting branch {branch} to {ref}. "
+                "Error: {error}".format(ref=ref, branch=branch, error=ex)
             )
             raise_from(exceptions.ResetException(msg), ex)

integration_tests/test_branch.py

@@ -123,3 +123,27 @@ def test_reset(repo_root):
     # Ensure the new head matches the origin/master we saved
     branch_commit = repo.repo.branches[branch_name].commit
     assert branch_commit.hexsha == reset_to_commit.hexsha
+
+
+def test_create_branch(repo_root):
+    repo = GitRepo(repo_root)
+    branch_name = "test_create"
+    tag_0_0_1_hexsha = "631b3a35723a038c01669e1933571693a166db81"
+    tag_0_1_0_hexsha = "2e6c014bc296be90a7ed04d155ea7d9da2240bbc"
+
+    assert branch_name not in repo.repo.branches
+
+    # Create the new branch
+    repo.branch.create(branch_name, "0.0.1")
+    assert branch_name in repo.repo.branches
+    assert repo.repo.branches[branch_name].commit.hexsha == tag_0_0_1_hexsha
+
+    # Branch already exists - do nothing
+    repo.branch.create(branch_name, "0.1.0")
+    assert branch_name in repo.repo.branches
+    assert repo.repo.branches[branch_name].commit.hexsha == tag_0_0_1_hexsha
+
+    # Branch already exists - reset it
+    repo.branch.create(branch_name, "0.1.0", True)
+    assert branch_name in repo.repo.branches
+    assert repo.repo.branches[branch_name].commit.hexsha == tag_0_1_0_hexsha

tests/conftest.py

@@ -21,7 +21,9 @@ def mock_repo():
     remote.configure_mock(name="origin", url="http://example.com")
     remote_list = IterableList("name")
     remote_list.extend([remote])
+
     repo_mock.remotes = remote_list
+    repo_mock.branches = []
 
     return repo_mock
 

tests/test_branch.py

@@ -658,8 +658,9 @@ def test_reset_checkout_failure(mock_repo):
     mock_repo.git.checkout.side_effect = git.GitCommandError('checkout', '')
     repo = GitRepo(repo=mock_repo)
 
-    with pytest.raises(exceptions.CheckoutException):
-        repo.branch.hard_reset(refresh=False)
+    with patch('git.repo.fun.name_to_object'):
+        with pytest.raises(exceptions.CheckoutException):
+            repo.branch.hard_reset(refresh=False)
 
     assert mock_repo.head.reset.called is False
 
@@ -743,3 +744,63 @@ def test_remote_branch_doesnt_exists(mock_repo):
     mock_repo.remotes.extend([remote])
 
     assert repo.branch.exists("testbranch", "testremote") is False
+
+
+def test_create_branch(mock_repo):
+    """
+    GIVEN GitRepo is initialized with a path and repo
+    WHEN branch.create is called with a valid name and start_ref
+    THEN git.branch is called
+    """
+    repo = GitRepo(repo=mock_repo)
+
+    with patch('git.repo.fun.name_to_object'):
+        assert repo.branch.create("test", "123456") is True
+    repo.git.branch.assert_called_with("test", "123456")
+
+
+def test_create_branch_with_bad_start_ref(mock_repo):
+    """
+    GIVEN GitRepo is initialized with a path and repo
+    WHEN branch.create is called with a valid name and invalid start_ref
+    THEN a ReferenceNotFoundException is raised
+    """
+    repo = GitRepo(repo=mock_repo)
+
+    with patch('git.repo.fun.name_to_object') as mock_name_to_object:
+        mock_name_to_object.side_effect = git.exc.BadName()
+        with pytest.raises(exceptions.ReferenceNotFoundException):
+            assert repo.branch.create("test", "badref")
+
+
+def test_create_branch_already_exists(mock_repo):
+    """
+    GIVEN GitRepo is initialized with a path and repo
+    WHEN branch.create is called with a valid name and start_ref
+    AND the branch already exists
+    THEN git.branch is not called
+    """
+    repo = GitRepo(repo=mock_repo)
+    mock_repo.branches = ["test", "master"]
+
+    with patch('git.repo.fun.name_to_object'):
+        repo.branch.create("test", "123456")
+    assert repo.git.branch.called is False
+
+
+def test_create_branch_already_exists_and_reset_it(mock_repo):
+    """
+    GIVEN GitRepo is initialized with a path and repo
+    WHEN branch.create is called with a valid name and start_ref
+    AND the branch already exists and reset_if_exists is True
+    THEN hard_reset_to_ref is called
+    """
+    repo = GitRepo(repo=mock_repo)
+    mock_repo.branches = ["test", "master"]
+
+    mock_hard_reset = Mock()
+    repo.branch.hard_reset_to_ref = mock_hard_reset
+
+    with patch('git.repo.fun.name_to_object'):
+        repo.branch.create("test", "123456", True)
+    assert mock_hard_reset.called is True