You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hop.apache.org by ha...@apache.org on 2026/08/19 13:53:25 UTC

(hop) branch main updated: allow remote branch delete and rename in git perspective. fixes #7996 (#7998)

This is an automated email from the ASF dual-hosted git repository.

hansva pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/hop.git


The following commit(s) were added to refs/heads/main by this push:
     new af08453b6e allow remote branch delete and rename in git perspective. fixes #7996 (#7998)
af08453b6e is described below

commit af08453b6ec58a8660bf973052f1b4827c3901c3
Author: Bart Maertens <ba...@know.bi>
AuthorDate: Wed Aug 19 15:53:17 2026 +0200

    allow remote branch delete and rename in git perspective. fixes #7996 (#7998)
---
 .../java/org/apache/hop/git/GitPerspective.java    | 141 ++++++++++-
 .../main/java/org/apache/hop/git/model/UIGit.java  | 260 ++++++++++++++++-----
 .../hop/git/messages/messages_en_US.properties     |   6 +
 .../java/org/apache/hop/git/model/UIGitTest.java   |  81 +++++++
 4 files changed, 431 insertions(+), 57 deletions(-)

diff --git a/plugins/misc/git/src/main/java/org/apache/hop/git/GitPerspective.java b/plugins/misc/git/src/main/java/org/apache/hop/git/GitPerspective.java
index 51de81518c..d182246341 100644
--- a/plugins/misc/git/src/main/java/org/apache/hop/git/GitPerspective.java
+++ b/plugins/misc/git/src/main/java/org/apache/hop/git/GitPerspective.java
@@ -392,12 +392,24 @@ public class GitPerspective implements IHopPerspective {
           boolean isRemotes = ref.getName().startsWith(Constants.R_REMOTES);
           boolean isTags = ref.getName().startsWith(Constants.R_TAGS);
 
+          // The default branch of the remote is off limits, renaming or deleting it breaks the
+          // repository for everyone. The remote is the one enforcing this, we only keep the
+          // obvious mistake out of reach.
+          //
+          boolean isProtectedRemote =
+              isRemotes && GitGuiPlugin.getInstance().getGit().isRemoteHead(ref.getName());
+
           setMenuItemEnabled(refMenuWidgets, REF_CONTEXT_MENU_CHECKOUT, !isCurrentBranch);
           setMenuItemEnabled(refMenuWidgets, REF_CONTEXT_MENU_PUSH, isHeads || isTags);
           setMenuItemEnabled(refMenuWidgets, REF_CONTEXT_MENU_PULL, isHeads);
-          setMenuItemEnabled(refMenuWidgets, REF_CONTEXT_MENU_RENAME, isHeads);
           setMenuItemEnabled(
-              refMenuWidgets, REF_CONTEXT_MENU_DELETE, !isCurrentBranch && (isHeads || isTags));
+              refMenuWidgets,
+              REF_CONTEXT_MENU_RENAME,
+              isHeads || (isRemotes && !isProtectedRemote));
+          setMenuItemEnabled(
+              refMenuWidgets,
+              REF_CONTEXT_MENU_DELETE,
+              !isCurrentBranch && (isHeads || isTags || (isRemotes && !isProtectedRemote)));
 
           MenuItem menuItem = refMenuWidgets.findMenuItem(REF_CONTEXT_MENU_CREATE_BRANCH);
           if (menuItem != null) {
@@ -1221,6 +1233,15 @@ public class GitPerspective implements IHopPerspective {
   public void renameReference() {
     Ref ref = this.getSelectedReference();
     if (ref != null) {
+      boolean isRemote = ref.getName().startsWith(Constants.R_REMOTES);
+      if (!isRemote && !ref.getName().startsWith(Constants.R_HEADS)) {
+        // Only branches can be renamed
+        return;
+      }
+      if (isRemote && GitGuiPlugin.getInstance().getGit().isRemoteHead(ref.getName())) {
+        return;
+      }
+
       UIGit git = GitGuiPlugin.getInstance().getGit();
       String oldName = git.getShortenedName(ref.getName());
 
@@ -1235,7 +1256,9 @@ public class GitPerspective implements IHopPerspective {
               case SWT.CR, SWT.KEYPAD_CR:
                 String newName = text.getText().trim();
                 if (!Utils.isEmpty(newName) && !newName.equals(oldName)) {
-                  if (git.renameBranch(oldName, newName)) {
+                  if (isRemote) {
+                    renameRemoteBranch(ref, oldName, newName);
+                  } else if (git.renameBranch(oldName, newName)) {
 
                     // If we rename the active branch
                     if (newName.equals(git.getBranch())) {
@@ -1276,6 +1299,8 @@ public class GitPerspective implements IHopPerspective {
     if (ref != null) {
       if (ref.getName().startsWith(Constants.R_HEADS)) {
         deleteBranch(ref);
+      } else if (ref.getName().startsWith(Constants.R_REMOTES)) {
+        deleteRemoteBranch(ref);
       } else if (ref.getName().startsWith(Constants.R_TAGS)) {
         deleteTag(ref);
       }
@@ -1308,6 +1333,116 @@ public class GitPerspective implements IHopPerspective {
     }
   }
 
+  /**
+   * Delete a branch on the remote. The branch is gone for everyone once this is pushed, so ask
+   * first and name the remote in the question.
+   */
+  protected void deleteRemoteBranch(Ref ref) {
+    if (ref == null) {
+      return;
+    }
+    UIGit git = GitGuiPlugin.getInstance().getGit();
+    String name = git.getShortenedName(ref.getName());
+
+    // The default branch of the remote is protected against an accidental delete
+    if (git.isRemoteHead(ref.getName())) {
+      return;
+    }
+
+    MessageBox dialog = new MessageBox(getShell(), SWT.ICON_WARNING | SWT.YES | SWT.NO);
+    dialog.setText(
+        BaseMessages.getString(
+            PKG, "GitGuiPlugin.Dialog.Branch.DeleteRemoteBranchConfirmation.Header"));
+    dialog.setMessage(
+        BaseMessages.getString(
+            PKG,
+            "GitGuiPlugin.Dialog.Branch.DeleteRemoteBranchConfirmation.Message",
+            getBranchOnRemote(name),
+            getRemoteName(name)));
+
+    if (dialog.open() == SWT.YES) {
+      try {
+        git.deleteRemoteBranch(ref.getName());
+      } catch (Exception e) {
+        new ErrorDialog(
+            getShell(),
+            BaseMessages.getString(PKG, "GitGuiPlugin.Dialog.PushError.Header"),
+            BaseMessages.getString(PKG, "GitGuiPlugin.Dialog.PushError.Message"),
+            e);
+      }
+
+      // Refresh refs and commit history
+      refresh(false);
+    }
+  }
+
+  /**
+   * Rename a branch on the remote. Git can't rename over the wire: the branch is pushed under its
+   * new name and the old one is deleted, so ask before doing it.
+   *
+   * @param ref the remote tracking ref of the branch
+   * @param oldName the current name including the remote, e.g. origin/feature
+   * @param newName the new name as typed by the user, with or without the remote prefix
+   */
+  private void renameRemoteBranch(Ref ref, String oldName, String newName) {
+    UIGit git = GitGuiPlugin.getInstance().getGit();
+
+    // The tree shows remote branches with their remote in front of them. Accept a new name with
+    // or without it, the branch is renamed on the same remote either way.
+    //
+    String remote = getRemoteName(oldName);
+    String newBranchName = newName.startsWith(remote + "/") ? getBranchOnRemote(newName) : newName;
+
+    if (Utils.isEmpty(newBranchName)
+        || !Repository.isValidRefName(Constants.R_HEADS + newBranchName)) {
+      MessageBox box = new MessageBox(getShell(), SWT.ICON_ERROR | SWT.OK);
+      box.setText(BaseMessages.getString(PKG, "GitGuiPlugin.Dialog.Branch.InvalidName.Header"));
+      box.setMessage(
+          BaseMessages.getString(PKG, "GitGuiPlugin.Dialog.Branch.InvalidName.Message", newName));
+      box.open();
+      return;
+    }
+
+    MessageBox dialog = new MessageBox(getShell(), SWT.ICON_WARNING | SWT.YES | SWT.NO);
+    dialog.setText(
+        BaseMessages.getString(
+            PKG, "GitGuiPlugin.Dialog.Branch.RenameRemoteBranchConfirmation.Header"));
+    dialog.setMessage(
+        BaseMessages.getString(
+            PKG,
+            "GitGuiPlugin.Dialog.Branch.RenameRemoteBranchConfirmation.Message",
+            getBranchOnRemote(oldName),
+            newBranchName,
+            remote));
+
+    if (dialog.open() == SWT.YES) {
+      try {
+        git.renameRemoteBranch(ref.getName(), newBranchName);
+      } catch (Exception e) {
+        new ErrorDialog(
+            getShell(),
+            BaseMessages.getString(PKG, "GitGuiPlugin.Dialog.PushError.Header"),
+            BaseMessages.getString(PKG, "GitGuiPlugin.Dialog.PushError.Message"),
+            e);
+      }
+
+      // Refresh refs and commit history
+      refresh(false);
+    }
+  }
+
+  /** The remote in a shortened remote branch name: origin/feature/hop gives origin. */
+  private static String getRemoteName(String shortenedName) {
+    int slashIndex = shortenedName.indexOf('/');
+    return slashIndex < 0 ? shortenedName : shortenedName.substring(0, slashIndex);
+  }
+
+  /** The branch name in a shortened remote branch name: origin/feature/hop gives feature/hop. */
+  private static String getBranchOnRemote(String shortenedName) {
+    int slashIndex = shortenedName.indexOf('/');
+    return slashIndex < 0 ? shortenedName : shortenedName.substring(slashIndex + 1);
+  }
+
   protected void deleteTag(Ref ref) {
     if (ref != null) {
       UIGit git = GitGuiPlugin.getInstance().getGit();
diff --git a/plugins/misc/git/src/main/java/org/apache/hop/git/model/UIGit.java b/plugins/misc/git/src/main/java/org/apache/hop/git/model/UIGit.java
index 6bc41c80af..728b6d28e9 100644
--- a/plugins/misc/git/src/main/java/org/apache/hop/git/model/UIGit.java
+++ b/plugins/misc/git/src/main/java/org/apache/hop/git/model/UIGit.java
@@ -85,6 +85,7 @@ import org.eclipse.jgit.lib.ObjectLoader;
 import org.eclipse.jgit.lib.ObjectReader;
 import org.eclipse.jgit.lib.PersonIdent;
 import org.eclipse.jgit.lib.Ref;
+import org.eclipse.jgit.lib.RefUpdate;
 import org.eclipse.jgit.lib.Repository;
 import org.eclipse.jgit.lib.RepositoryState;
 import org.eclipse.jgit.lib.StoredConfig;
@@ -706,25 +707,167 @@ public class UIGit extends VCS {
     return push(new RefSpec(":" + getExpandedName(name, VCS.TYPE_TAG)));
   }
 
+  /**
+   * Delete a branch on the remote: git push origin :refs/heads/name
+   *
+   * <p>The remote tracking ref is removed as well, a delete doesn't prune it automatically.
+   *
+   * @param trackingRefName the name of the remote tracking ref, e.g. refs/remotes/origin/feature
+   */
+  public boolean deleteRemoteBranch(String trackingRefName) throws HopException {
+    String[] remoteAndBranch = splitTrackingRefName(trackingRefName);
+    String remote = remoteAndBranch[0];
+    String branch = remoteAndBranch[1];
+
+    if (!push(remote, List.of(new RefSpec(":" + Constants.R_HEADS + branch)), true)) {
+      return false;
+    }
+    deleteTrackingRef(trackingRefName);
+    return true;
+  }
+
+  /**
+   * Rename a branch on the remote. Git has no rename over the wire: the branch is pushed under its
+   * new name first and only removed under the old name once that succeeded.
+   *
+   * @param trackingRefName the name of the remote tracking ref, e.g. refs/remotes/origin/feature
+   * @param newBranchName the new name of the branch on the remote, without the remote prefix
+   */
+  public boolean renameRemoteBranch(String trackingRefName, String newBranchName)
+      throws HopException {
+    String[] remoteAndBranch = splitTrackingRefName(trackingRefName);
+    String remote = remoteAndBranch[0];
+    String oldBranchName = remoteAndBranch[1];
+
+    try {
+      Ref ref = git.getRepository().findRef(trackingRefName);
+      if (ref == null) {
+        throw new HopException("Remote branch '" + trackingRefName + "' could not be found");
+      }
+
+      // Create the branch under its new name, at the commit the old one points at.
+      // Bail out if the remote rejects it: the old branch is all that is left otherwise.
+      //
+      String commitId = ref.getObjectId().name();
+      if (!push(
+          remote,
+          List.of(new RefSpec(commitId + ":" + Constants.R_HEADS + newBranchName)),
+          false)) {
+        return false;
+      }
+
+      if (!push(remote, List.of(new RefSpec(":" + Constants.R_HEADS + oldBranchName)), true)) {
+        return false;
+      }
+
+      // Keep the tracking refs in step, the rename is only picked up by the next fetch otherwise
+      //
+      updateTrackingRef(Constants.R_REMOTES + remote + "/" + newBranchName, ref.getObjectId());
+      deleteTrackingRef(trackingRefName);
+      return true;
+    } catch (HopException e) {
+      throw e;
+    } catch (Exception e) {
+      throw new HopException(
+          "There was an error renaming remote branch '" + trackingRefName + "'", e);
+    }
+  }
+
+  /**
+   * Split a remote tracking ref name into the remote and the name of the branch on that remote:
+   * refs/remotes/origin/feature/hop becomes origin and feature/hop.
+   */
+  private String[] splitTrackingRefName(String trackingRefName) throws HopException {
+    if (!trackingRefName.startsWith(Constants.R_REMOTES)) {
+      throw new HopException("'" + trackingRefName + "' is not a remote branch");
+    }
+    // A branch name can contain slashes, so match on the configured remotes instead of splitting
+    // on the first slash.
+    //
+    String name = trackingRefName.substring(Constants.R_REMOTES.length());
+    for (String remote : git.getRepository().getRemoteNames()) {
+      if (name.startsWith(remote + "/")) {
+        return new String[] {remote, name.substring(remote.length() + 1)};
+      }
+    }
+    throw new HopException("No remote configured for remote branch '" + trackingRefName + "'");
+  }
+
+  /** Point a remote tracking ref at a commit locally, without touching the remote. */
+  private void updateTrackingRef(String trackingRefName, ObjectId objectId) throws HopException {
+    try {
+      RefUpdate update = git.getRepository().updateRef(trackingRefName);
+      update.setNewObjectId(objectId);
+      update.setForceUpdate(true);
+      update.update();
+    } catch (IOException e) {
+      throw new HopException("Unable to update remote tracking ref '" + trackingRefName + "'", e);
+    }
+  }
+
+  /** Remove a remote tracking ref locally, without touching the remote. */
+  private void deleteTrackingRef(String trackingRefName) throws HopException {
+    try {
+      RefUpdate update = git.getRepository().updateRef(trackingRefName);
+      update.setForceUpdate(true);
+      update.delete();
+    } catch (IOException e) {
+      throw new HopException("Unable to remove remote tracking ref '" + trackingRefName + "'", e);
+    }
+  }
+
+  /**
+   * Check whether a remote branch is the default branch (HEAD) of its remote. That is only known
+   * when the remote HEAD was fetched, so a false doesn't guarantee the branch is safe to remove:
+   * the remote has the final say.
+   *
+   * @param trackingRefName the name of the remote tracking ref, e.g. refs/remotes/origin/main
+   */
+  public boolean isRemoteHead(String trackingRefName) {
+    try {
+      String[] remoteAndBranch = splitTrackingRefName(trackingRefName);
+      Ref head = git.getRepository().exactRef(Constants.R_REMOTES + remoteAndBranch[0] + "/HEAD");
+      return head != null
+          && head.isSymbolic()
+          && head.getTarget().getName().equals(trackingRefName);
+    } catch (Exception e) {
+      return false;
+    }
+  }
+
   private boolean push(RefSpec refSpec) throws HopException {
+    return push(Constants.DEFAULT_REMOTE_NAME, refSpec == null ? null : List.of(refSpec), true);
+  }
+
+  /**
+   * Push a set of refspecs to a remote.
+   *
+   * @param remote the name of the remote to push to
+   * @param refSpecs the refspecs to push, null to push the default refspec
+   * @param reportSuccess report a successful push to the user. Set this to false for a push that is
+   *     only a step in a larger operation, the caller reports on the end result then.
+   * @return true if every ref was updated on the remote
+   */
+  private boolean push(String remote, List<RefSpec> refSpecs, boolean reportSuccess)
+      throws HopException {
     if (!hasRemote()) {
       throw new HopException("There is no remote set up to push to. Please set this up.");
     }
     try {
       PushCommand cmd = git.push();
+      cmd.setRemote(remote);
 
-      String url = git.getRepository().getConfig().getString("remote", "origin", "url");
+      String url = git.getRepository().getConfig().getString("remote", remote, "url");
       if (!StringUtils.isEmpty(url) && (url.startsWith("https://") || url.startsWith("http://"))) {
         cmd.setCredentialsProvider(credentialsProvider);
       }
 
-      if (refSpec != null) {
-        cmd.setRefSpecs(refSpec);
+      if (refSpecs != null) {
+        cmd.setRefSpecs(refSpecs);
       }
 
       Iterable<PushResult> resultIterable = cmd.call();
-      processPushResult(resultIterable);
-      return true;
+      return processPushResult(resultIterable, reportSuccess);
     } catch (TransportException e) {
       if (e.getMessage()
               .contains(
@@ -732,7 +875,7 @@ public class UIGit extends VCS {
           || e.getMessage()
               .contains(CONST_NOT_AUTHORIZED)) { // when the cached credential does not work
         if (promptUsernamePassword()) {
-          return push(refSpec);
+          return push(remote, refSpecs, reportSuccess);
         }
       } else {
         throw new HopException("There was an error doing a git push", e);
@@ -743,55 +886,64 @@ public class UIGit extends VCS {
     return false;
   }
 
-  private void processPushResult(Iterable<PushResult> resultIterable) {
-    resultIterable.forEach(
-        result -> { // for each (push)url
-          StringBuilder sb = new StringBuilder();
-          result.getRemoteUpdates().stream()
-              .filter(update -> update.getStatus() != RemoteRefUpdate.Status.OK)
-              .filter(update -> update.getStatus() != RemoteRefUpdate.Status.UP_TO_DATE)
-              // Deleting a ref that is already gone on the remote is not an error
-              .filter(update -> update.getStatus() != RemoteRefUpdate.Status.NON_EXISTING)
-              .forEach(
-                  // for each failed refspec
-                  update -> {
-                    boolean isTag = update.getRemoteName().startsWith(Constants.R_TAGS);
-                    sb.append("Errors while pushing: ")
-                        .append("\n")
-                        .append("Destination: ")
-                        .append(result.getURI().toString())
-                        .append("\n")
-                        .append(isTag ? "Tag name: " : "Branch name: ")
-                        // A delete has no source ref, report the ref on the remote instead
-                        .append(Repository.shortenRefName(update.getRemoteName()))
+  /**
+   * Report on the outcome of a push.
+   *
+   * @return true if every ref was updated on the remote
+   */
+  private boolean processPushResult(Iterable<PushResult> resultIterable, boolean reportSuccess) {
+    boolean success = true;
+    for (PushResult result : resultIterable) { // for each (push)url
+      StringBuilder sb = new StringBuilder();
+      result.getRemoteUpdates().stream()
+          .filter(update -> update.getStatus() != RemoteRefUpdate.Status.OK)
+          .filter(update -> update.getStatus() != RemoteRefUpdate.Status.UP_TO_DATE)
+          // Deleting a ref that is already gone on the remote is not an error
+          .filter(update -> update.getStatus() != RemoteRefUpdate.Status.NON_EXISTING)
+          .forEach(
+              // for each failed refspec
+              update -> {
+                boolean isTag = update.getRemoteName().startsWith(Constants.R_TAGS);
+                sb.append("Errors while pushing: ")
+                    .append("\n")
+                    .append("Destination: ")
+                    .append(result.getURI().toString())
+                    .append("\n")
+                    .append(isTag ? "Tag name: " : "Branch name: ")
+                    // A delete has no source ref, report the ref on the remote instead
+                    .append(Repository.shortenRefName(update.getRemoteName()))
+                    .append("\n");
+                switch (update.getStatus()) {
+                  case REJECTED_NONFASTFORWARD:
+                    sb.append(" * ")
+                        .append(update.getStatus().toString())
+                        .append(
+                            isTag
+                                ? " - The tag already exists on the remote and points to another commit."
+                                : " - Remote repository contains changes. Merge the remote changes (e.g. 'git pull') before pushing again.")
                         .append("\n");
-                    switch (update.getStatus()) {
-                      case REJECTED_NONFASTFORWARD:
-                        sb.append(" * ")
-                            .append(update.getStatus().toString())
-                            .append(
-                                isTag
-                                    ? " - The tag already exists on the remote and points to another commit."
-                                    : " - Remote repository contains changes. Merge the remote changes (e.g. 'git pull') before pushing again.")
-                            .append("\n");
-                        break;
-                      default:
-                        sb.append(" * ")
-                            .append(update.getStatus().toString())
-                            .append(" - ")
-                            .append(update.getMessage() == null ? "" : "\n" + update.getMessage())
-                            .append("\n");
-                        break;
-                    }
-                  });
-          if (sb.isEmpty()) {
-            showMessageBox(
-                BaseMessages.getString(PKG, "Dialog.Success"),
-                BaseMessages.getString(PKG, "Dialog.Success"));
-          } else {
-            showMessageBox(BaseMessages.getString(PKG, CONST_DIALOG_ERROR), sb.toString());
-          }
-        });
+                    break;
+                  default:
+                    sb.append(" * ")
+                        .append(update.getStatus().toString())
+                        .append(" - ")
+                        .append(update.getMessage() == null ? "" : "\n" + update.getMessage())
+                        .append("\n");
+                    break;
+                }
+              });
+      if (sb.isEmpty()) {
+        if (reportSuccess) {
+          showMessageBox(
+              BaseMessages.getString(PKG, "Dialog.Success"),
+              BaseMessages.getString(PKG, "Dialog.Success"));
+        }
+      } else {
+        success = false;
+        showMessageBox(BaseMessages.getString(PKG, CONST_DIALOG_ERROR), sb.toString());
+      }
+    }
+    return success;
   }
 
   public String diff(String oldCommitId, String newCommitId) {
diff --git a/plugins/misc/git/src/main/resources/org/apache/hop/git/messages/messages_en_US.properties b/plugins/misc/git/src/main/resources/org/apache/hop/git/messages/messages_en_US.properties
index 8e6aff175e..863dc8a946 100644
--- a/plugins/misc/git/src/main/resources/org/apache/hop/git/messages/messages_en_US.properties
+++ b/plugins/misc/git/src/main/resources/org/apache/hop/git/messages/messages_en_US.properties
@@ -31,12 +31,18 @@ GitGuiPlugin.Dialog.Branch.DeleteBranchConfirmation.Header=Delete a Branch
 GitGuiPlugin.Dialog.Branch.DeleteBranchConfirmation.Message=Are you sure you want to delete branch ''{0}'' ?
 GitGuiPlugin.Dialog.Branch.DeleteBranchSuccessFul.Header=Branch Deleted
 GitGuiPlugin.Dialog.Branch.DeleteBranchSuccessFul.Message=Branch deleted Successfully
+GitGuiPlugin.Dialog.Branch.DeleteRemoteBranchConfirmation.Header=Delete a Remote Branch
+GitGuiPlugin.Dialog.Branch.DeleteRemoteBranchConfirmation.Message=Are you sure you want to delete branch ''{0}'' on remote ''{1}'' ?\n\nThe branch is deleted for everyone using this repository.
+GitGuiPlugin.Dialog.Branch.InvalidName.Header=Invalid Branch Name
+GitGuiPlugin.Dialog.Branch.InvalidName.Message=''{0}'' is not a valid branch name.
 GitGuiPlugin.Dialog.Branch.MergeBranch.Header=Merge Branch
 GitGuiPlugin.Dialog.Branch.MergeBranch.Message=Select the branch you want to merge
 GitGuiPlugin.Dialog.Branch.MergeBranchSuccessFul.Header=Merge successful
 GitGuiPlugin.Dialog.Branch.MergeBranchSuccessFul.Message=Successful merge
 GitGuiPlugin.Dialog.Branch.RenameBranch.Header=Rename a Branch
 GitGuiPlugin.Dialog.Branch.RenameBranch.Message=New branch name
+GitGuiPlugin.Dialog.Branch.RenameRemoteBranchConfirmation.Header=Rename a Remote Branch
+GitGuiPlugin.Dialog.Branch.RenameRemoteBranchConfirmation.Message=Rename branch ''{0}'' to ''{1}'' on remote ''{2}'' ?\n\nGit has no rename on a remote: the branch is pushed under its new name and the old one is deleted. Anyone working with this branch has to update their local repository.
 GitGuiPlugin.Dialog.CherryPickCommit.Header=Cherry-pick commit
 GitGuiPlugin.Dialog.CherryPickCommitRepositoryIsNotClean.Message=Please clean your repository working tree before cherry-picking commit.
 GitGuiPlugin.Dialog.CherryPickCommitConflicts.Message=There were conflicts while cherry-picking commit ''{0}''\n\n{1}
diff --git a/plugins/misc/git/src/test/java/org/apache/hop/git/model/UIGitTest.java b/plugins/misc/git/src/test/java/org/apache/hop/git/model/UIGitTest.java
index eed022cf71..1e0b14e391 100644
--- a/plugins/misc/git/src/test/java/org/apache/hop/git/model/UIGitTest.java
+++ b/plugins/misc/git/src/test/java/org/apache/hop/git/model/UIGitTest.java
@@ -21,6 +21,8 @@ package org.apache.hop.git.model;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
@@ -41,6 +43,7 @@ import java.util.List;
 import java.util.Set;
 import org.apache.commons.io.FileUtils;
 import org.apache.commons.io.IOUtils;
+import org.apache.hop.core.exception.HopException;
 import org.apache.hop.git.model.revision.ObjectRevision;
 import org.apache.hop.ui.core.dialog.EnterSelectionDialog;
 import org.eclipse.jgit.api.Git;
@@ -391,6 +394,84 @@ public class UIGitTest extends RepositoryTestCase {
     git2.close();
   }
 
+  @Test
+  public void testDeleteRemoteBranch() throws Exception {
+    Git git2 = new Git(db2);
+    UIGit uiGit2 = new UIGit();
+    uiGit2.setGit(git2);
+    setupRemote();
+
+    git.commit().setMessage("initial commit").call();
+    git.branchCreate().setName("feature/test").call();
+
+    // A branch name with a slash in it: the remote is origin, the branch is feature/test
+    assertTrue(uiGit.push(VCS.TYPE_BRANCH, "feature/test"));
+    git.fetch().call();
+    assertTrue(uiGit2.getLocalBranches().contains("feature/test"));
+    assertNotNull(db.findRef("refs/remotes/origin/feature/test"));
+
+    assertTrue(uiGit.deleteRemoteBranch("refs/remotes/origin/feature/test"));
+    assertFalse(uiGit2.getLocalBranches().contains("feature/test"));
+
+    // The tracking ref is removed as well, deleting on the remote doesn't prune it
+    assertNull(db.findRef("refs/remotes/origin/feature/test"));
+
+    git2.close();
+  }
+
+  @Test
+  public void testDeleteRemoteBranchWithoutRemote() throws Exception {
+    git.commit().setMessage("initial commit").call();
+
+    assertThrows(HopException.class, () -> uiGit.deleteRemoteBranch("refs/remotes/origin/feature"));
+  }
+
+  @Test
+  public void testRenameRemoteBranch() throws Exception {
+    Git git2 = new Git(db2);
+    UIGit uiGit2 = new UIGit();
+    uiGit2.setGit(git2);
+    setupRemote();
+
+    RevCommit commit = git.commit().setMessage("initial commit").call();
+    git.branchCreate().setName("old").call();
+    assertTrue(uiGit.push(VCS.TYPE_BRANCH, "old"));
+    git.fetch().call();
+
+    assertTrue(uiGit.renameRemoteBranch("refs/remotes/origin/old", "new"));
+
+    // The branch is created under its new name and removed under the old one, pointing at the
+    // same commit
+    assertTrue(uiGit2.getLocalBranches().contains("new"));
+    assertFalse(uiGit2.getLocalBranches().contains("old"));
+    assertEquals(commit.getId(), db2.resolve("refs/heads/new"));
+
+    // The tracking refs follow along, without needing a fetch
+    assertNull(db.findRef("refs/remotes/origin/old"));
+    assertNotNull(db.findRef("refs/remotes/origin/new"));
+
+    git2.close();
+  }
+
+  @Test
+  public void testIsRemoteHead() throws Exception {
+    setupRemote();
+
+    git.commit().setMessage("initial commit").call();
+    git.branchCreate().setName("feature").call();
+    assertTrue(uiGit.push(VCS.TYPE_BRANCH, "feature"));
+    git.fetch().call();
+
+    // Without a remote HEAD there is nothing to protect
+    assertFalse(uiGit.isRemoteHead("refs/remotes/origin/feature"));
+
+    db.updateRef("refs/remotes/origin/HEAD").link("refs/remotes/origin/feature");
+    assertTrue(uiGit.isRemoteHead("refs/remotes/origin/feature"));
+
+    // Local branches and tags are never a remote HEAD
+    assertFalse(uiGit.isRemoteHead("refs/heads/master"));
+  }
+
   @Test
   public void testShouldPushOnlyToOrigin() throws Exception {
     // origin for db2