Example usage for org.eclipse.jgit.transport PushResult getRemoteUpdate

Introduction

In this page you can find the example usage for org.eclipse.jgit.transport PushResult getRemoteUpdate.

Prototype

public RemoteRefUpdate getRemoteUpdate(String refName) 

Source Link

Document

Get status of specific remote ref update by remote ref name.

Usage

From source file:ch.sbb.releasetrain.git.GitRepoImpl.java

License:Apache License

/**
 * Use with care!//  ww  w . j  a v  a 2s .  c o m
 */
public boolean deleteBranch() {
    if (!branch.startsWith("feature/")) {
        throw new GitException("Can only delete feature branch.");
    }
    try {

        final Git git = gitOpen();
        git.checkout().setCreateBranch(true).setName("feature/temp_" + UUID.randomUUID()).call();
        List<String> deletedBranches = git.branchDelete().setBranchNames(branch).setForce(true).call();
        if (deletedBranches.size() == 1) {
            // delete branch 'branchToDelete' on remote 'origin'
            RefSpec refSpec = new RefSpec().setSource(null).setDestination("refs/heads/" + branch);
            Iterable<PushResult> results = git.push().setCredentialsProvider(credentialsProvider())
                    .setRefSpecs(refSpec).setRemote("origin").call();
            for (PushResult result : results) {
                RemoteRefUpdate myUpdate = result.getRemoteUpdate("refs/heads/" + branch);
                if (myUpdate.isDelete() && myUpdate.getStatus() == RemoteRefUpdate.Status.OK) {
                    return true;
                }
            }
        }
        return false;
    } catch (IOException | GitAPIException e) {
        throw new GitException("Delete branch failed", e);
    }
}

---

From source file:com.barchart.jenkins.cascade.PluginScm.java

License:BSD License

/**
 * Transmit into remote./*from w  w w.j a  v  a  2 s  . c om*/
 */
public static void scmCheckin(final BuildContext<CascadeBuild> context, final MavenModuleSet project)
        throws IOException, InterruptedException {

    final String message = checkScm(project);

    if (message != null) {
        throw new IllegalStateException(message);
    }

    final GitSCM gitScm = (GitSCM) project.getScm();
    final FilePath workspace = workspace(context, project);

    /** Remote objects. */
    final BuildLogger logger = context.logger();
    final String localBranch = localBranchName(gitScm);
    final String remoteName = remoteName(gitScm);
    final String remoteBranch = remoteBranchName(gitScm);

    /** Remote operation. */
    final FileCallable<Void> callable = new FileCallable<Void>() {

        private static final long serialVersionUID = 1L;

        public Void invoke(final File basedir, final VirtualChannel channel)
                throws IOException, InterruptedException {

            final RefSpec pushSpec = PluginScmGit.refPush(localBranch, remoteBranch);

            final Iterable<PushResult> pushResultList = PluginScmGit.doPush(basedir, remoteName, pushSpec);

            final PushResult pushResult = pushResultList.iterator().next();

            final String refHeads = PluginScmGit.refHeads(remoteBranch);

            final RemoteRefUpdate remoteUpdate = pushResult.getRemoteUpdate(refHeads);

            final RemoteRefUpdate.Status pushStatus = remoteUpdate.getStatus();

            logger.logTab("push status: " + pushStatus);

            if (!PluginScmGit.isSuccess(pushStatus)) {
                throw new IllegalStateException("Unexpected");
            }

            return null;
        }
    };

    workspace.act(callable);

}

---

From source file:com.gitblit.servlet.GitServletTest.java

License:Apache License

private void testCommitterVerification(UserModel user, String displayName, String emailAddress,
        boolean expectedSuccess) throws Exception {

    delete(user);//from  ww  w .  jav  a2s . c  o m

    CredentialsProvider cp = new UsernamePasswordCredentialsProvider(user.username, user.password);

    // fork from original to a temporary bare repo
    File verification = new File(GitBlitSuite.REPOSITORIES, "refchecks/verify-committer.git");
    if (verification.exists()) {
        FileUtils.delete(verification, FileUtils.RECURSIVE);
    }
    CloneCommand clone = Git.cloneRepository();
    clone.setURI(MessageFormat.format("{0}/ticgit.git", url));
    clone.setDirectory(verification);
    clone.setBare(true);
    clone.setCloneAllBranches(true);
    clone.setCredentialsProvider(cp);
    GitBlitSuite.close(clone.call());

    // require push permissions and committer verification
    RepositoryModel model = repositories().getRepositoryModel("refchecks/verify-committer.git");
    model.authorizationControl = AuthorizationControl.NAMED;
    model.accessRestriction = AccessRestrictionType.PUSH;
    model.verifyCommitter = true;

    // grant user push permission
    user.setRepositoryPermission(model.name, AccessPermission.PUSH);

    gitblit().addUser(user);
    repositories().updateRepositoryModel(model.name, model, false);

    // clone temp bare repo to working copy
    File local = new File(GitBlitSuite.REPOSITORIES, "refchecks/verify-wc");
    if (local.exists()) {
        FileUtils.delete(local, FileUtils.RECURSIVE);
    }
    clone = Git.cloneRepository();
    clone.setURI(MessageFormat.format("{0}/{1}", url, model.name));
    clone.setDirectory(local);
    clone.setBare(false);
    clone.setCloneAllBranches(true);
    clone.setCredentialsProvider(cp);
    GitBlitSuite.close(clone.call());

    Git git = Git.open(local);

    // force an identity which may or may not match the account's identity
    git.getRepository().getConfig().setString("user", null, "name", displayName);
    git.getRepository().getConfig().setString("user", null, "email", emailAddress);
    git.getRepository().getConfig().save();

    // commit a file and push it
    File file = new File(local, "PUSHCHK");
    OutputStreamWriter os = new OutputStreamWriter(new FileOutputStream(file, true), Constants.CHARSET);
    BufferedWriter w = new BufferedWriter(os);
    w.write("// " + new Date().toString() + "\n");
    w.close();
    git.add().addFilepattern(file.getName()).call();
    git.commit().setMessage("push test").call();
    Iterable<PushResult> results = git.push().setCredentialsProvider(cp).setRemote("origin").call();

    for (PushResult result : results) {
        RemoteRefUpdate ref = result.getRemoteUpdate("refs/heads/master");
        Status status = ref.getStatus();
        if (expectedSuccess) {
            assertTrue("Verification failed! User was NOT able to push commit! " + status.name(),
                    Status.OK.equals(status));
        } else {
            assertTrue("Verification failed! User was able to push commit! " + status.name(),
                    Status.REJECTED_OTHER_REASON.equals(status));
        }
    }

    GitBlitSuite.close(git);
    // close serving repository
    GitBlitSuite.close(verification);
}

---

From source file:com.gitblit.servlet.GitServletTest.java

License:Apache License

private void testMergeCommitterVerification(boolean expectedSuccess) throws Exception {
    UserModel user = getUser();// w  w  w .  ja v a2  s.c om

    delete(user);

    CredentialsProvider cp = new UsernamePasswordCredentialsProvider(user.username, user.password);

    // fork from original to a temporary bare repo
    File verification = new File(GitBlitSuite.REPOSITORIES, "refchecks/verify-committer.git");
    if (verification.exists()) {
        FileUtils.delete(verification, FileUtils.RECURSIVE);
    }
    CloneCommand clone = Git.cloneRepository();
    clone.setURI(MessageFormat.format("{0}/ticgit.git", url));
    clone.setDirectory(verification);
    clone.setBare(true);
    clone.setCloneAllBranches(true);
    clone.setCredentialsProvider(cp);
    GitBlitSuite.close(clone.call());

    // require push permissions and committer verification
    RepositoryModel model = repositories().getRepositoryModel("refchecks/verify-committer.git");
    model.authorizationControl = AuthorizationControl.NAMED;
    model.accessRestriction = AccessRestrictionType.PUSH;
    model.verifyCommitter = true;

    // grant user push permission
    user.setRepositoryPermission(model.name, AccessPermission.PUSH);

    gitblit().addUser(user);
    repositories().updateRepositoryModel(model.name, model, false);

    // clone temp bare repo to working copy
    File local = new File(GitBlitSuite.REPOSITORIES, "refchecks/verify-wc");
    if (local.exists()) {
        FileUtils.delete(local, FileUtils.RECURSIVE);
    }
    clone = Git.cloneRepository();
    clone.setURI(MessageFormat.format("{0}/{1}", url, model.name));
    clone.setDirectory(local);
    clone.setBare(false);
    clone.setCloneAllBranches(true);
    clone.setCredentialsProvider(cp);
    GitBlitSuite.close(clone.call());

    Git git = Git.open(local);

    // checkout a mergetest branch
    git.checkout().setCreateBranch(true).setName("mergetest").call();

    // change identity
    git.getRepository().getConfig().setString("user", null, "name", "mergetest");
    git.getRepository().getConfig().setString("user", null, "email", "mergetest@merge.com");
    git.getRepository().getConfig().save();

    // commit a file
    File file = new File(local, "MERGECHK2");
    OutputStreamWriter os = new OutputStreamWriter(new FileOutputStream(file, true), Constants.CHARSET);
    BufferedWriter w = new BufferedWriter(os);
    w.write("// " + new Date().toString() + "\n");
    w.close();
    git.add().addFilepattern(file.getName()).call();
    RevCommit mergeTip = git.commit().setMessage(file.getName() + " test").call();

    // return to master
    git.checkout().setName("master").call();

    // restore identity
    if (expectedSuccess) {
        git.getRepository().getConfig().setString("user", null, "name", user.username);
        git.getRepository().getConfig().setString("user", null, "email", user.emailAddress);
        git.getRepository().getConfig().save();
    }

    // commit a file
    file = new File(local, "MERGECHK1");
    os = new OutputStreamWriter(new FileOutputStream(file, true), Constants.CHARSET);
    w = new BufferedWriter(os);
    w.write("// " + new Date().toString() + "\n");
    w.close();
    git.add().addFilepattern(file.getName()).call();
    git.commit().setMessage(file.getName() + " test").call();

    // merge the tip of the mergetest branch into master with --no-ff
    MergeResult mergeResult = git.merge().setFastForward(FastForwardMode.NO_FF).include(mergeTip.getId())
            .call();
    assertEquals(MergeResult.MergeStatus.MERGED, mergeResult.getMergeStatus());

    // push the merged master to the origin
    Iterable<PushResult> results = git.push().setCredentialsProvider(cp).setRemote("origin").call();

    for (PushResult result : results) {
        RemoteRefUpdate ref = result.getRemoteUpdate("refs/heads/master");
        Status status = ref.getStatus();
        if (expectedSuccess) {
            assertTrue("Verification failed! User was NOT able to push commit! " + status.name(),
                    Status.OK.equals(status));
        } else {
            assertTrue("Verification failed! User was able to push commit! " + status.name(),
                    Status.REJECTED_OTHER_REASON.equals(status));
        }
    }

    GitBlitSuite.close(git);
    // close serving repository
    GitBlitSuite.close(verification);
}

---

From source file:com.gitblit.servlet.GitServletTest.java

License:Apache License

private void testRefChange(AccessPermission permission, Status expectedCreate, Status expectedDelete,
        Status expectedRewind) throws Exception {

    final String originName = "ticgit.git";
    final String forkName = "refchecks/ticgit.git";
    final String workingCopy = "refchecks/ticgit-wc";

    // lower access restriction on origin repository
    RepositoryModel origin = repositories().getRepositoryModel(originName);
    origin.accessRestriction = AccessRestrictionType.NONE;
    repositories().updateRepositoryModel(origin.name, origin, false);

    UserModel user = getUser();/*from   ww  w  .  j a v  a  2  s.c  o m*/
    delete(user);

    CredentialsProvider cp = new UsernamePasswordCredentialsProvider(user.username, user.password);

    // fork from original to a temporary bare repo
    File refChecks = new File(GitBlitSuite.REPOSITORIES, forkName);
    if (refChecks.exists()) {
        FileUtils.delete(refChecks, FileUtils.RECURSIVE);
    }
    CloneCommand clone = Git.cloneRepository();
    clone.setURI(url + "/" + originName);
    clone.setDirectory(refChecks);
    clone.setBare(true);
    clone.setCloneAllBranches(true);
    clone.setCredentialsProvider(cp);
    GitBlitSuite.close(clone.call());

    // elevate repository to clone permission
    RepositoryModel model = repositories().getRepositoryModel(forkName);
    switch (permission) {
    case VIEW:
        model.accessRestriction = AccessRestrictionType.CLONE;
        break;
    case CLONE:
        model.accessRestriction = AccessRestrictionType.CLONE;
        break;
    default:
        model.accessRestriction = AccessRestrictionType.PUSH;
    }
    model.authorizationControl = AuthorizationControl.NAMED;

    // grant user specified
    user.setRepositoryPermission(model.name, permission);

    gitblit().addUser(user);
    repositories().updateRepositoryModel(model.name, model, false);

    // clone temp bare repo to working copy
    File local = new File(GitBlitSuite.REPOSITORIES, workingCopy);
    if (local.exists()) {
        FileUtils.delete(local, FileUtils.RECURSIVE);
    }
    clone = Git.cloneRepository();
    clone.setURI(MessageFormat.format("{0}/{1}", url, model.name));
    clone.setDirectory(local);
    clone.setBare(false);
    clone.setCloneAllBranches(true);
    clone.setCredentialsProvider(cp);

    try {
        GitBlitSuite.close(clone.call());
    } catch (GitAPIException e) {
        if (permission.atLeast(AccessPermission.CLONE)) {
            throw e;
        } else {
            // close serving repository
            GitBlitSuite.close(refChecks);

            // user does not have clone permission
            assertTrue(e.getMessage(), e.getMessage().contains("not permitted"));
            return;
        }
    }

    Git git = Git.open(local);

    // commit a file and push it
    File file = new File(local, "PUSHCHK");
    OutputStreamWriter os = new OutputStreamWriter(new FileOutputStream(file, true), Constants.CHARSET);
    BufferedWriter w = new BufferedWriter(os);
    w.write("// " + new Date().toString() + "\n");
    w.close();
    git.add().addFilepattern(file.getName()).call();
    git.commit().setMessage("push test").call();
    Iterable<PushResult> results = null;
    try {
        results = git.push().setCredentialsProvider(cp).setRemote("origin").call();
    } catch (GitAPIException e) {
        if (permission.atLeast(AccessPermission.PUSH)) {
            throw e;
        } else {
            // close serving repository
            GitBlitSuite.close(refChecks);

            // user does not have push permission
            assertTrue(e.getMessage(), e.getMessage().contains("not permitted"));
            GitBlitSuite.close(git);
            return;
        }
    }

    for (PushResult result : results) {
        RemoteRefUpdate ref = result.getRemoteUpdate("refs/heads/master");
        Status status = ref.getStatus();
        if (permission.atLeast(AccessPermission.PUSH)) {
            assertTrue("User failed to push commit?! " + status.name(), Status.OK.equals(status));
        } else {
            // close serving repository
            GitBlitSuite.close(refChecks);

            assertTrue("User was able to push commit! " + status.name(),
                    Status.REJECTED_OTHER_REASON.equals(status));
            GitBlitSuite.close(git);
            // skip delete test
            return;
        }
    }

    // create a local branch and push the new branch back to the origin
    git.branchCreate().setName("protectme").call();
    RefSpec refSpec = new RefSpec("refs/heads/protectme:refs/heads/protectme");
    results = git.push().setCredentialsProvider(cp).setRefSpecs(refSpec).setRemote("origin").call();
    for (PushResult result : results) {
        RemoteRefUpdate ref = result.getRemoteUpdate("refs/heads/protectme");
        Status status = ref.getStatus();
        if (Status.OK.equals(expectedCreate)) {
            assertTrue("User failed to push creation?! " + status.name(), status.equals(expectedCreate));
        } else {
            // close serving repository
            GitBlitSuite.close(refChecks);

            assertTrue("User was able to push ref creation! " + status.name(), status.equals(expectedCreate));
            GitBlitSuite.close(git);
            // skip delete test
            return;
        }
    }

    // delete the branch locally
    git.branchDelete().setBranchNames("protectme").call();

    // push a delete ref command
    refSpec = new RefSpec(":refs/heads/protectme");
    results = git.push().setCredentialsProvider(cp).setRefSpecs(refSpec).setRemote("origin").call();
    for (PushResult result : results) {
        RemoteRefUpdate ref = result.getRemoteUpdate("refs/heads/protectme");
        Status status = ref.getStatus();
        if (Status.OK.equals(expectedDelete)) {
            assertTrue("User failed to push ref deletion?! " + status.name(), status.equals(Status.OK));
        } else {
            // close serving repository
            GitBlitSuite.close(refChecks);

            assertTrue("User was able to push ref deletion?! " + status.name(), status.equals(expectedDelete));
            GitBlitSuite.close(git);
            // skip rewind test
            return;
        }
    }

    // rewind master by two commits
    git.reset().setRef("HEAD~2").setMode(ResetType.HARD).call();

    // commit a change on this detached HEAD
    file = new File(local, "REWINDCHK");
    os = new OutputStreamWriter(new FileOutputStream(file, true), Constants.CHARSET);
    w = new BufferedWriter(os);
    w.write("// " + new Date().toString() + "\n");
    w.close();
    git.add().addFilepattern(file.getName()).call();
    RevCommit commit = git.commit().setMessage("rewind master and new commit").call();

    // Reset master to our new commit now we our local branch tip is no longer
    // upstream of the remote branch tip.  It is an alternate tip of the branch.
    JGitUtils.setBranchRef(git.getRepository(), "refs/heads/master", commit.getName());

    // Try pushing our new tip to the origin.
    // This requires the server to "rewind" it's master branch and update it
    // to point to our alternate tip.  This leaves the original master tip
    // unreferenced.
    results = git.push().setCredentialsProvider(cp).setRemote("origin").setForce(true).call();
    for (PushResult result : results) {
        RemoteRefUpdate ref = result.getRemoteUpdate("refs/heads/master");
        Status status = ref.getStatus();
        if (Status.OK.equals(expectedRewind)) {
            assertTrue("User failed to rewind master?! " + status.name(), status.equals(expectedRewind));
        } else {
            assertTrue("User was able to rewind master?! " + status.name(), status.equals(expectedRewind));
        }
    }
    GitBlitSuite.close(git);

    // close serving repository
    GitBlitSuite.close(refChecks);

    delete(user);
}

---

From source file:com.gitblit.servlet.GitServletTest.java

License:Apache License

private void testCreateOnPush(boolean canCreate, boolean canAdmin) throws Exception {

    UserModel user = new UserModel("sampleuser");
    user.password = user.username;//from   w  w  w.  ja  va2  s.  co  m

    delete(user);

    user.canCreate = canCreate;
    user.canAdmin = canAdmin;

    gitblit().addUser(user);

    CredentialsProvider cp = new UsernamePasswordCredentialsProvider(user.username, user.password);

    // fork from original to a temporary bare repo
    File tmpFolder = File.createTempFile("gitblit", "").getParentFile();
    File createCheck = new File(tmpFolder, "ticgit.git");
    if (createCheck.exists()) {
        FileUtils.delete(createCheck, FileUtils.RECURSIVE);
    }

    File personalRepo = new File(GitBlitSuite.REPOSITORIES,
            MessageFormat.format("~{0}/ticgit.git", user.username));
    GitBlitSuite.close(personalRepo);
    if (personalRepo.exists()) {
        FileUtils.delete(personalRepo, FileUtils.RECURSIVE);
    }

    File projectRepo = new File(GitBlitSuite.REPOSITORIES, "project/ticgit.git");
    GitBlitSuite.close(projectRepo);
    if (projectRepo.exists()) {
        FileUtils.delete(projectRepo, FileUtils.RECURSIVE);
    }

    CloneCommand clone = Git.cloneRepository();
    clone.setURI(MessageFormat.format("{0}/ticgit.git", url));
    clone.setDirectory(createCheck);
    clone.setBare(true);
    clone.setCloneAllBranches(true);
    clone.setCredentialsProvider(cp);
    Git git = clone.call();

    GitBlitSuite.close(personalRepo);

    // add a personal repository remote and a project remote
    git.getRepository().getConfig().setString("remote", "user", "url",
            MessageFormat.format("{0}/~{1}/ticgit.git", url, user.username));
    git.getRepository().getConfig().setString("remote", "project", "url",
            MessageFormat.format("{0}/project/ticgit.git", url));
    git.getRepository().getConfig().save();

    // push to non-existent user repository
    try {
        Iterable<PushResult> results = git.push().setRemote("user").setPushAll().setCredentialsProvider(cp)
                .call();

        for (PushResult result : results) {
            RemoteRefUpdate ref = result.getRemoteUpdate("refs/heads/master");
            Status status = ref.getStatus();
            assertTrue("User failed to create repository?! " + status.name(), Status.OK.equals(status));
        }

        assertTrue("User canAdmin:" + user.canAdmin + " canCreate:" + user.canCreate,
                user.canAdmin || user.canCreate);

        // confirm default personal repository permissions
        RepositoryModel model = repositories()
                .getRepositoryModel(MessageFormat.format("~{0}/ticgit.git", user.username));
        assertEquals("Unexpected owner", user.username, ArrayUtils.toString(model.owners));
        assertEquals("Unexpected authorization control", AuthorizationControl.NAMED,
                model.authorizationControl);
        assertEquals("Unexpected access restriction", AccessRestrictionType.VIEW, model.accessRestriction);

    } catch (GitAPIException e) {
        assertTrue(e.getMessage(), e.getMessage().contains("git-receive-pack not found"));
        assertFalse("User canAdmin:" + user.canAdmin + " canCreate:" + user.canCreate,
                user.canAdmin || user.canCreate);
    }

    // push to non-existent project repository
    try {
        Iterable<PushResult> results = git.push().setRemote("project").setPushAll().setCredentialsProvider(cp)
                .call();
        GitBlitSuite.close(git);

        for (PushResult result : results) {
            RemoteRefUpdate ref = result.getRemoteUpdate("refs/heads/master");
            Status status = ref.getStatus();
            assertTrue("User failed to create repository?! " + status.name(), Status.OK.equals(status));
        }

        assertTrue("User canAdmin:" + user.canAdmin, user.canAdmin);

        // confirm default project repository permissions
        RepositoryModel model = repositories().getRepositoryModel("project/ticgit.git");
        assertEquals("Unexpected owner", user.username, ArrayUtils.toString(model.owners));
        assertEquals("Unexpected authorization control",
                AuthorizationControl
                        .fromName(settings().getString(Keys.git.defaultAuthorizationControl, "NAMED")),
                model.authorizationControl);
        assertEquals("Unexpected access restriction",
                AccessRestrictionType.fromName(settings().getString(Keys.git.defaultAccessRestriction, "NONE")),
                model.accessRestriction);

    } catch (GitAPIException e) {
        assertTrue(e.getMessage(), e.getMessage().contains("git-receive-pack not found"));
        assertFalse("User canAdmin:" + user.canAdmin, user.canAdmin);
    }

    GitBlitSuite.close(git);
    delete(user);
}

---

From source file:com.gitblit.tests.TicketReferenceTest.java

License:Apache License

@Test
public void commitTicketBranchDeletePostMergeReference() throws Exception {
    setPatchsetAvailable(false);/*ww w  .  java  2s. co m*/

    TicketModel a = ticketService.createTicket(repo, newTicket("commitTicketBranchDeletePostMergeReference-A"));
    TicketModel b = ticketService.createTicket(repo, newTicket("commitTicketBranchDeletePostMergeReference-B"));
    TicketModel c = ticketService.createTicket(repo, newTicket("commitTicketBranchDeletePostMergeReference-C"));
    assertFalse(c.hasPatchsets());

    String branchName = String.format("ticket/%d", c.number);
    git.checkout().setCreateBranch(true).setName(branchName).call();

    String message = String.format("commit before amend for #%d and #%d", a.number, b.number);
    final RevCommit revCommit1 = makeCommit(message);
    final String commit1Sha = revCommit1.name();
    assertPushSuccess(commit1Sha, branchName);

    a = ticketService.getTicket(repo, a.number);
    b = ticketService.getTicket(repo, b.number);
    c = ticketService.getTicket(repo, c.number);
    assertTrue(a.hasReferences());
    assertTrue(b.hasReferences());
    assertFalse(c.hasReferences());

    List<Reference> cRefA = a.getReferences();
    assertNotNull(cRefA);
    assertEquals(1, cRefA.size());
    assertNull(cRefA.get(0).ticketId);
    assertEquals(commit1Sha, cRefA.get(0).hash);

    List<Reference> cRefB = b.getReferences();
    assertNotNull(cRefB);
    assertEquals(1, cRefB.size());
    assertNull(cRefB.get(0).ticketId);
    assertEquals(commit1Sha, cRefB.get(0).hash);

    git.checkout().setCreateBranch(false).setName("refs/heads/master").call();

    // merge the tip of the branch into master
    MergeResult mergeResult = git.merge().setFastForward(FastForwardMode.NO_FF).include(revCommit1.getId())
            .call();
    assertEquals(MergeResult.MergeStatus.MERGED, mergeResult.getMergeStatus());

    // push the merged master to the origin
    Iterable<PushResult> results = git.push().setCredentialsProvider(cp).setRemote("origin").call();
    for (PushResult result : results) {
        RemoteRefUpdate ref = result.getRemoteUpdate("refs/heads/master");
        assertEquals(Status.OK, ref.getStatus());
    }

    //As everything has been merged no references should be changed
    assertDeleteBranch(branchName);

    a = ticketService.getTicket(repo, a.number);
    b = ticketService.getTicket(repo, b.number);
    c = ticketService.getTicket(repo, c.number);
    assertTrue(a.hasReferences());
    assertTrue(b.hasReferences());
    assertFalse(c.hasReferences());

    cRefA = a.getReferences();
    assertNotNull(cRefA);
    assertEquals(1, cRefA.size());
    assertNull(cRefA.get(0).ticketId);
    assertEquals(commit1Sha, cRefA.get(0).hash);

    cRefB = b.getReferences();
    assertNotNull(cRefB);
    assertEquals(1, cRefB.size());
    assertNull(cRefB.get(0).ticketId);
    assertEquals(commit1Sha, cRefB.get(0).hash);
}

---

From source file:com.gitblit.tests.TicketReferenceTest.java

License:Apache License

private void assertPushSuccess(String commitSha, String branchName) throws Exception {
    Iterable<PushResult> results = git.push().setRemote("origin").setCredentialsProvider(cp).call();

    for (PushResult result : results) {
        RemoteRefUpdate ref = result.getRemoteUpdate("refs/heads/" + branchName);
        assertEquals(Status.OK, ref.getStatus());
        assertEquals(commitSha, ref.getNewObjectId().name());
    }/*from ww  w  .j a  va2s .  c  om*/
}

---

From source file:com.gitblit.tests.TicketReferenceTest.java

License:Apache License

private void assertForcePushSuccess(String commitSha, String branchName) throws Exception {
    Iterable<PushResult> results = git.push().setForce(true).setRemote("origin").setCredentialsProvider(cp)
            .call();/*w  w w  .  j av  a2  s  .c  om*/

    for (PushResult result : results) {
        RemoteRefUpdate ref = result.getRemoteUpdate("refs/heads/" + branchName);
        assertEquals(Status.OK, ref.getStatus());
        assertEquals(commitSha, ref.getNewObjectId().name());
    }
}

---

From source file:com.gitblit.tests.TicketReferenceTest.java

License:Apache License

private void assertDeleteBranch(String branchName) throws Exception {

    RefSpec refSpec = new RefSpec().setSource(null).setDestination("refs/heads/" + branchName);

    Iterable<PushResult> results = git.push().setRefSpecs(refSpec).setRemote("origin")
            .setCredentialsProvider(cp).call();

    for (PushResult result : results) {
        RemoteRefUpdate ref = result.getRemoteUpdate("refs/heads/" + branchName);
        assertEquals(Status.OK, ref.getStatus());
    }// w  w  w  . ja va 2s .co  m
}

---

• «
• 1
• 2
• »