src/test/java/com/gitblit/tests/TicketReferenceTest.java

/*
 * Copyright 2016 gitblit.com.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.gitblit.tests;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
import java.text.MessageFormat;
import java.util.Date;
import java.util.List;

import org.eclipse.jgit.api.CloneCommand;
import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.api.MergeResult;
import org.eclipse.jgit.api.MergeCommand.FastForwardMode;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.transport.CredentialsProvider;
import org.eclipse.jgit.transport.PushResult;
import org.eclipse.jgit.transport.RefSpec;
import org.eclipse.jgit.transport.RemoteRefUpdate;
import org.eclipse.jgit.transport.UsernamePasswordCredentialsProvider;
import org.eclipse.jgit.transport.RemoteRefUpdate.Status;
import org.eclipse.jgit.util.FileUtils;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;

import com.gitblit.Constants.AccessPermission;
import com.gitblit.Constants.AccessRestrictionType;
import com.gitblit.Constants.AuthorizationControl;
import com.gitblit.GitBlitException;
import com.gitblit.models.RepositoryModel;
import com.gitblit.models.TicketModel;
import com.gitblit.models.UserModel;
import com.gitblit.models.TicketModel.Change;
import com.gitblit.models.TicketModel.Field;
import com.gitblit.models.TicketModel.Reference;
import com.gitblit.tickets.ITicketService;

/**
 * Creates and deletes a range of ticket references via ticket comments and commits 
 */
public class TicketReferenceTest extends GitblitUnitTest {

	static File workingCopy = new File(GitBlitSuite.REPOSITORIES, "working/TicketReferenceTest.git-wc");
	
	static ITicketService ticketService;
	
	static final String account = "TicketRefTest";
	static final String password = GitBlitSuite.password;

	static final String url = GitBlitSuite.gitServletUrl;
	
	static UserModel user = null;
	static RepositoryModel repo = null;
	static CredentialsProvider cp = null;
	static Git git = null;
	
	@BeforeClass
	public static void configure() throws Exception {
		File repositoryName = new File("TicketReferenceTest.git");;
		
		GitBlitSuite.close(repositoryName);
		if (repositoryName.exists()) {
			FileUtils.delete(repositoryName, FileUtils.RECURSIVE | FileUtils.RETRY);
		}
		repo = new RepositoryModel("TicketReferenceTest.git", null, null, null);
		
		if (gitblit().hasRepository(repo.name)) {
			gitblit().deleteRepositoryModel(repo);
		}
		
		gitblit().updateRepositoryModel(repo.name, repo, true);
		
		user = new UserModel(account);
		user.displayName = account;
		user.emailAddress = account + "@example.com";
		user.password = password;

		cp = new UsernamePasswordCredentialsProvider(user.username, user.password);
		
		if (gitblit().getUserModel(user.username) != null) {
			gitblit().deleteUser(user.username);
		}

		repo.authorizationControl = AuthorizationControl.NAMED;
		repo.accessRestriction = AccessRestrictionType.PUSH;
		gitblit().updateRepositoryModel(repo.name, repo, false);
		
		// grant user push permission
		user.setRepositoryPermission(repo.name, AccessPermission.REWIND);
		gitblit().updateUserModel(user);

		ticketService = gitblit().getTicketService();
		assertTrue(ticketService.deleteAll(repo));
		
		GitBlitSuite.close(workingCopy);
		if (workingCopy.exists()) {
			FileUtils.delete(workingCopy, FileUtils.RECURSIVE | FileUtils.RETRY);
		}
		
		CloneCommand clone = Git.cloneRepository();
		clone.setURI(MessageFormat.format("{0}/{1}", url, repo.name));
		clone.setDirectory(workingCopy);
		clone.setBare(false);
		clone.setBranch("master");
		clone.setCredentialsProvider(cp);
		GitBlitSuite.close(clone.call());
		
		git = Git.open(workingCopy);
		git.getRepository().getConfig().setString("user", null, "name", user.displayName);
		git.getRepository().getConfig().setString("user", null, "email", user.emailAddress);
		git.getRepository().getConfig().save();
		
		final RevCommit revCommit1 = makeCommit("initial commit");
		final String initialSha = revCommit1.name();
		Iterable<PushResult> results = git.push().setPushAll().setCredentialsProvider(cp).call();
		GitBlitSuite.close(git);
		for (PushResult result : results) {
			for (RemoteRefUpdate update : result.getRemoteUpdates()) {
				assertEquals(Status.OK, update.getStatus());
				assertEquals(initialSha, update.getNewObjectId().name());
			}
		}
	}
	
	@AfterClass
	public static void cleanup() throws Exception {
		GitBlitSuite.close(git);
	}
	
	@Test
	public void noReferencesOnTicketCreation() throws Exception {

		TicketModel a = ticketService.createTicket(repo, newTicket("noReferencesOnCreation"));
		assertNotNull(a);
		assertFalse(a.hasReferences());
		
		//Ensure retrieval process doesn't affect anything
		a = ticketService.getTicket(repo,  a.number);
		assertNotNull(a);
		assertFalse(a.hasReferences());
	}
	
	
	@Test
	public void commentNoUnexpectedReference() throws Exception {
		
		TicketModel a = ticketService.createTicket(repo, newTicket("commentNoUnexpectedReference-A"));
		TicketModel b = ticketService.createTicket(repo, newTicket("commentNoUnexpectedReference-B"));
		
		assertNotNull(ticketService.updateTicket(repo, a.number, newComment("comment for 1 - no reference")));
		assertNotNull(ticketService.updateTicket(repo, a.number, newComment("comment for # - no reference")));
		assertNotNull(ticketService.updateTicket(repo, a.number, newComment("comment for #999 - ignores invalid reference")));

		a = ticketService.getTicket(repo, a.number);
		b = ticketService.getTicket(repo, b.number);

		assertFalse(a.hasReferences());
		assertFalse(b.hasReferences());
	}
	
	@Test
	public void commentNoSelfReference() throws Exception {
			
		TicketModel a = ticketService.createTicket(repo, newTicket("commentNoSelfReference-A"));
		
		final Change comment = newComment(String.format("comment for #%d - no self reference", a.number));
		assertNotNull(ticketService.updateTicket(repo, a.number, comment)); 
		
		a = ticketService.getTicket(repo, a.number);
		
		assertFalse(a.hasReferences());
	}
	
	@Test
	public void commentSingleReference() throws Exception {
		
		TicketModel a = ticketService.createTicket(repo, newTicket("commentSingleReference-A"));
		TicketModel b = ticketService.createTicket(repo, newTicket("commentSingleReference-B"));
		
		final Change comment = newComment(String.format("comment for #%d - single reference", b.number));
		assertNotNull(ticketService.updateTicket(repo, a.number, comment));
		
		a = ticketService.getTicket(repo, a.number);
		b = ticketService.getTicket(repo, b.number);
		
		assertFalse(a.hasReferences());
		assertTrue(b.hasReferences());
		
		List<Reference> cRefB = b.getReferences();
		assertNotNull(cRefB);
		assertEquals(1, cRefB.size());
		assertEquals(a.number, cRefB.get(0).ticketId.longValue());
		assertEquals(comment.comment.id, cRefB.get(0).hash);
	}
		
	@Test
	public void commentSelfAndOtherReference() throws Exception {
		TicketModel a = ticketService.createTicket(repo, newTicket("commentSelfAndOtherReference-A"));
		TicketModel b = ticketService.createTicket(repo, newTicket("commentSelfAndOtherReference-B"));
		
		final Change comment = newComment(String.format("comment for #%d and #%d - self and other reference", a.number, b.number));
		assertNotNull(ticketService.updateTicket(repo, a.number, comment));
		
		a = ticketService.getTicket(repo, a.number);
		b = ticketService.getTicket(repo, b.number);

		assertFalse(a.hasReferences());
		assertTrue(b.hasReferences());
		
		List<Reference> cRefB = b.getReferences();
		assertNotNull(cRefB);
		assertEquals(1, cRefB.size());
		assertEquals(a.number, cRefB.get(0).ticketId.longValue());
		assertEquals(comment.comment.id, cRefB.get(0).hash);
	}
	
	@Test
	public void commentMultiReference() throws Exception {
		TicketModel a = ticketService.createTicket(repo, newTicket("commentMultiReference-A"));
		TicketModel b = ticketService.createTicket(repo, newTicket("commentMultiReference-B"));
		TicketModel c = ticketService.createTicket(repo, newTicket("commentMultiReference-C"));
		
		final Change comment = newComment(String.format("comment for #%d and #%d - multi reference", b.number, c.number));
		assertNotNull(ticketService.updateTicket(repo, a.number, comment));
		
		a = ticketService.getTicket(repo, a.number);
		b = ticketService.getTicket(repo, b.number);
		c = ticketService.getTicket(repo, c.number);

		assertFalse(a.hasReferences());
		assertTrue(b.hasReferences());
		assertTrue(c.hasReferences());
		
		List<Reference> cRefB = b.getReferences();
		assertNotNull(cRefB);
		assertEquals(1, cRefB.size());
		assertEquals(a.number, cRefB.get(0).ticketId.longValue());
		assertEquals(comment.comment.id, cRefB.get(0).hash);
		
		List<Reference> cRefC = c.getReferences();
		assertNotNull(cRefC);
		assertEquals(1, cRefC.size());
		assertEquals(a.number, cRefC.get(0).ticketId.longValue());
		assertEquals(comment.comment.id, cRefC.get(0).hash);
	}
	
	

	@Test
	public void commitMasterNoUnexpectedReference() throws Exception {
		TicketModel a = ticketService.createTicket(repo, newTicket("commentMultiReference-A"));
		
		final String branchName = "master";
		git.checkout().setCreateBranch(false).setName(branchName).call();
		
		makeCommit("commit for 1 - no reference");
		makeCommit("comment for # - no reference");
		final RevCommit revCommit1 = makeCommit("comment for #999 - ignores invalid reference");
		final String commit1Sha = revCommit1.name();
		
		assertPushSuccess(commit1Sha, branchName);
		
		a = ticketService.getTicket(repo, a.number);
		assertFalse(a.hasReferences());
	}
	
	@Test
	public void commitMasterSingleReference() throws Exception {
		TicketModel a = ticketService.createTicket(repo, newTicket("commitMasterSingleReference-A"));
		
		final String branchName = "master";
		git.checkout().setCreateBranch(false).setName(branchName).call();
		
		final String message = String.format("commit for #%d - single reference", a.number);
		final RevCommit revCommit1 = makeCommit(message);
		final String commit1Sha = revCommit1.name();
		
		assertPushSuccess(commit1Sha, branchName);
		
		a = ticketService.getTicket(repo, a.number);
		assertTrue(a.hasReferences());
		
		List<Reference> cRefA = a.getReferences();
		assertNotNull(cRefA);
		assertEquals(1, cRefA.size());
		assertNull(cRefA.get(0).ticketId);
		assertEquals(commit1Sha, cRefA.get(0).hash);
	}
	
	@Test
	public void commitMasterMultiReference() throws Exception {
		TicketModel a = ticketService.createTicket(repo, newTicket("commitMasterMultiReference-A"));
		TicketModel b = ticketService.createTicket(repo, newTicket("commitMasterMultiReference-B"));
		
		final String branchName = "master";
		git.checkout().setCreateBranch(false).setName(branchName).call();
		
		final String message = String.format("commit for #%d and #%d - multi reference", 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);
		assertTrue(a.hasReferences());
		assertTrue(b.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 = a.getReferences();
		assertNotNull(cRefB);
		assertEquals(1, cRefB.size());
		assertNull(cRefB.get(0).ticketId);
		assertEquals(commit1Sha, cRefB.get(0).hash);
	}
	
	@Test
	public void commitMasterAmendReference() throws Exception {
		TicketModel a = ticketService.createTicket(repo, newTicket("commitMasterAmendReference-A"));
		TicketModel b = ticketService.createTicket(repo, newTicket("commitMasterAmendReference-B"));
		
		final String branchName = "master";
		git.checkout().setCreateBranch(false).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);
		assertTrue(a.hasReferences());
		assertTrue(b.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);
		
		//Confirm that old invalid references removed for both tickets
		//and new reference added for one referenced ticket
		message = String.format("commit after amend for #%d", a.number);
		final String commit2Sha = amendCommit(message);
		
		assertForcePushSuccess(commit2Sha, branchName);
		
		a = ticketService.getTicket(repo, a.number);
		b = ticketService.getTicket(repo, b.number);
		assertTrue(a.hasReferences());
		assertFalse(b.hasReferences());
		
		cRefA = a.getReferences();
		assertNotNull(cRefA);
		assertEquals(1, cRefA.size());
		assertNull(cRefA.get(0).ticketId);
		assertEquals(commit2Sha, cRefA.get(0).hash);
	}
	
	
	@Test
	public void commitPatchsetNoUnexpectedReference() throws Exception {
		setPatchsetAvailable(true);
		TicketModel a = ticketService.createTicket(repo, newTicket("commitPatchsetNoUnexpectedReference-A"));
		
		String branchName = String.format("ticket/%d", a.number);
		git.checkout().setCreateBranch(true).setName(branchName).call();
		
		makeCommit("commit for 1 - no reference");
		makeCommit("commit for # - no reference");
		final String message = "commit for #999 - ignores invalid reference";
		final RevCommit revCommit1 = makeCommit(message);
		final String commit1Sha = revCommit1.name();
		
		assertPushSuccess(commit1Sha, branchName);
		
		a = ticketService.getTicket(repo, a.number);
		assertFalse(a.hasReferences());
	}

	@Test
	public void commitPatchsetNoSelfReference() throws Exception {
		setPatchsetAvailable(true);
		TicketModel a = ticketService.createTicket(repo, newTicket("commitPatchsetNoSelfReference-A"));
		
		String branchName = String.format("ticket/%d", a.number);
		git.checkout().setCreateBranch(true).setName(branchName).call();
		
		final String message = String.format("commit for #%d - patchset self reference", a.number);
		final RevCommit revCommit1 = makeCommit(message);
		final String commit1Sha = revCommit1.name();
		
		assertPushSuccess(commit1Sha, branchName);
		
		a = ticketService.getTicket(repo, a.number);
		assertFalse(a.hasReferences());
	}
	
	@Test
	public void commitPatchsetSingleReference() throws Exception {
		setPatchsetAvailable(true);
		TicketModel a = ticketService.createTicket(repo, newTicket("commitPatchsetSingleReference-A"));
		TicketModel b = ticketService.createTicket(repo, newTicket("commitPatchsetSingleReference-B"));
		
		String branchName = String.format("ticket/%d", a.number);
		git.checkout().setCreateBranch(true).setName(branchName).call();
		
		final String message = String.format("commit for #%d - patchset single reference", 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);
		assertFalse(a.hasReferences());
		assertTrue(b.hasReferences());
		
		List<Reference> cRefB = b.getReferences();
		assertNotNull(cRefB);
		assertEquals(1, cRefB.size());
		assertNull(cRefB.get(0).ticketId);
		assertEquals(commit1Sha, cRefB.get(0).hash);
	}
	
	@Test
	public void commitPatchsetMultiReference() throws Exception {
		setPatchsetAvailable(true);
		TicketModel a = ticketService.createTicket(repo, newTicket("commitPatchsetMultiReference-A"));
		TicketModel b = ticketService.createTicket(repo, newTicket("commitPatchsetMultiReference-B"));
		TicketModel c = ticketService.createTicket(repo, newTicket("commitPatchsetMultiReference-C"));
		
		String branchName = String.format("ticket/%d", a.number);
		git.checkout().setCreateBranch(true).setName(branchName).call();
		
		final String message = String.format("commit for #%d and #%d- patchset multi reference", b.number, c.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);
		assertFalse(a.hasReferences());
		assertTrue(b.hasReferences());
		assertTrue(c.hasReferences());
		
		List<Reference> cRefB = b.getReferences();
		assertNotNull(cRefB);
		assertEquals(1, cRefB.size());
		assertNull(cRefB.get(0).ticketId);
		assertEquals(commit1Sha, cRefB.get(0).hash);
		
		List<Reference> cRefC = c.getReferences();
		assertNotNull(cRefC);
		assertEquals(1, cRefC.size());
		assertNull(cRefC.get(0).ticketId);
		assertEquals(commit1Sha, cRefC.get(0).hash);
	}
	
	@Test
	public void commitPatchsetAmendReference() throws Exception {
		setPatchsetAvailable(true);

		TicketModel a = ticketService.createTicket(repo, newTicket("commitPatchsetAmendReference-A"));
		TicketModel b = ticketService.createTicket(repo, newTicket("commitPatchsetAmendReference-B"));
		TicketModel c = ticketService.createTicket(repo, newTicket("commitPatchsetAmendReference-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());
		
		assertTrue(c.hasPatchsets());
		assertNotNull(c.getPatchset(1, 1));
		
		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);
		
		//As a new patchset is created the references will remain until deleted
		message = String.format("commit after amend for #%d", a.number);
		final String commit2Sha = amendCommit(message);

		assertForcePushSuccess(commit2Sha, 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());
		
		assertNotNull(c.getPatchset(1, 1));
		assertNotNull(c.getPatchset(2, 1));
		
		cRefA = a.getReferences();
		assertNotNull(cRefA);
		assertEquals(2, cRefA.size());
		assertNull(cRefA.get(0).ticketId);
		assertNull(cRefA.get(1).ticketId);
		assertEquals(commit1Sha, cRefA.get(0).hash);
		assertEquals(commit2Sha, cRefA.get(1).hash);
		
		cRefB = b.getReferences();
		assertNotNull(cRefB);
		assertEquals(1, cRefB.size());
		assertNull(cRefB.get(0).ticketId);
		assertEquals(commit1Sha, cRefB.get(0).hash);
		
		//Delete the original patchset and confirm old references are removed
		ticketService.deletePatchset(c, c.getPatchset(1, 1), user.username);
		
		a = ticketService.getTicket(repo, a.number);
		b = ticketService.getTicket(repo, b.number);
		c = ticketService.getTicket(repo, c.number);
		assertTrue(a.hasReferences());
		assertFalse(b.hasReferences());
		assertFalse(c.hasReferences());
		
		assertNull(c.getPatchset(1, 1));
		assertNotNull(c.getPatchset(2, 1));
		
		cRefA = a.getReferences();
		assertNotNull(cRefA);
		assertEquals(1, cRefA.size());
		assertNull(cRefA.get(0).ticketId);
		assertEquals(commit2Sha, cRefA.get(0).hash);
	}
		
	
	@Test
	public void commitTicketBranchNoUnexpectedReference() throws Exception {
		setPatchsetAvailable(false);
		TicketModel a = ticketService.createTicket(repo, newTicket("commitTicketBranchNoUnexpectedReference-A"));
		
		String branchName = String.format("ticket/%d", a.number);
		git.checkout().setCreateBranch(true).setName(branchName).call();
		
		makeCommit("commit for 1 - no reference");
		makeCommit("commit for # - no reference");
		final String message = "commit for #999 - ignores invalid reference";
		final RevCommit revCommit1 = makeCommit(message);
		final String commit1Sha = revCommit1.name();
		assertPushSuccess(commit1Sha, branchName);
		
		a = ticketService.getTicket(repo, a.number);
		assertFalse(a.hasReferences());
	}

	@Test
	public void commitTicketBranchSelfReference() throws Exception {
		setPatchsetAvailable(false);
		TicketModel a = ticketService.createTicket(repo, newTicket("commitTicketBranchSelfReference-A"));
		
		String branchName = String.format("ticket/%d", a.number);
		git.checkout().setCreateBranch(true).setName(branchName).call();
		
		final String message = String.format("commit for #%d - patchset self reference", a.number);
		final RevCommit revCommit1 = makeCommit(message);
		final String commit1Sha = revCommit1.name();
		
		assertPushSuccess(commit1Sha, branchName);
		
		a = ticketService.getTicket(repo, a.number);
		assertTrue(a.hasReferences());
		
		List<Reference> cRefA = a.getReferences();
		assertNotNull(cRefA);
		assertEquals(1, cRefA.size());
		assertNull(cRefA.get(0).ticketId);
		assertEquals(commit1Sha, cRefA.get(0).hash);
	}
	
	@Test
	public void commitTicketBranchSingleReference() throws Exception {
		setPatchsetAvailable(false);
		TicketModel a = ticketService.createTicket(repo, newTicket("commitTicketBranchSingleReference-A"));
		TicketModel b = ticketService.createTicket(repo, newTicket("commitTicketBranchSingleReference-B"));
		
		String branchName = String.format("ticket/%d", a.number);
		git.checkout().setCreateBranch(true).setName(branchName).call();
		
		final String message = String.format("commit for #%d - patchset single reference", 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);
		assertFalse(a.hasReferences());
		assertTrue(b.hasReferences());
		
		List<Reference> cRefB = b.getReferences();
		assertNotNull(cRefB);
		assertEquals(1, cRefB.size());
		assertNull(cRefB.get(0).ticketId);
		assertEquals(commit1Sha, cRefB.get(0).hash);
	}
	
	@Test
	public void commitTicketBranchMultiCommit() throws Exception {
		setPatchsetAvailable(false);
		TicketModel a = ticketService.createTicket(repo, newTicket("commitTicketBranchMultiCommit-A"));
		TicketModel b = ticketService.createTicket(repo, newTicket("commitTicketBranchMultiCommit-B"));
		
		String branchName = String.format("ticket/%d", a.number);
		git.checkout().setCreateBranch(true).setName(branchName).call();
		
		final String message1 = String.format("commit for #%d - patchset multi commit 1", b.number);
		final RevCommit revCommit1 = makeCommit(message1);
		final String commit1Sha = revCommit1.name();
		
		final String message2 = String.format("commit for #%d - patchset multi commit 2", b.number);
		final RevCommit revCommit2 = makeCommit(message2);
		final String commit2Sha = revCommit2.name();
		
		assertPushSuccess(commit2Sha, branchName);
		
		a = ticketService.getTicket(repo, a.number);
		b = ticketService.getTicket(repo, b.number);
		assertFalse(a.hasReferences());
		assertTrue(b.hasReferences());
		
		List<Reference> cRefB = b.getReferences();
		assertNotNull(cRefB);
		assertEquals(2, cRefB.size());
		assertNull(cRefB.get(0).ticketId);
		assertEquals(commit1Sha, cRefB.get(1).hash);
		assertEquals(commit2Sha, cRefB.get(0).hash);
	}
	
	@Test
	public void commitTicketBranchMultiReference() throws Exception {
		setPatchsetAvailable(false);
		TicketModel a = ticketService.createTicket(repo, newTicket("commitTicketBranchMultiReference-A"));
		TicketModel b = ticketService.createTicket(repo, newTicket("commitTicketBranchMultiReference-B"));
		TicketModel c = ticketService.createTicket(repo, newTicket("commitTicketBranchMultiReference-C"));
		
		String branchName = String.format("ticket/%d", a.number);
		git.checkout().setCreateBranch(true).setName(branchName).call();
		
		final String message = String.format("commit for #%d and #%d- patchset multi reference", b.number, c.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);
		assertFalse(a.hasReferences());
		assertTrue(b.hasReferences());
		assertTrue(c.hasReferences());
		
		List<Reference> cRefB = b.getReferences();
		assertNotNull(cRefB);
		assertEquals(1, cRefB.size());
		assertNull(cRefB.get(0).ticketId);
		assertEquals(commit1Sha, cRefB.get(0).hash);
		
		List<Reference> cRefC = c.getReferences();
		assertNotNull(cRefC);
		assertEquals(1, cRefC.size());
		assertNull(cRefC.get(0).ticketId);
		assertEquals(commit1Sha, cRefC.get(0).hash);
	}
	
	@Test
	public void commitTicketBranchAmendReference() throws Exception {
		setPatchsetAvailable(false);

		TicketModel a = ticketService.createTicket(repo, newTicket("commitTicketBranchAmendReference-A"));
		TicketModel b = ticketService.createTicket(repo, newTicket("commitTicketBranchAmendReference-B"));
		TicketModel c = ticketService.createTicket(repo, newTicket("commitTicketBranchAmendReference-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());
		assertFalse(c.hasPatchsets());
		
		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);
		
		//Confirm that old invalid references removed for both tickets
		//and new reference added for one referenced ticket
		message = String.format("commit after amend for #%d", a.number);
		final String commit2Sha = amendCommit(message);
		
		assertForcePushSuccess(commit2Sha, branchName);
		
		a = ticketService.getTicket(repo, a.number);
		b = ticketService.getTicket(repo, b.number);
		c = ticketService.getTicket(repo, c.number);
		assertTrue(a.hasReferences());
		assertFalse(b.hasReferences());
		assertFalse(c.hasReferences());
		assertFalse(c.hasPatchsets());
		
		cRefA = a.getReferences();
		assertNotNull(cRefA);
		assertEquals(1, cRefA.size());
		assertNull(cRefA.get(0).ticketId);
		assertEquals(commit2Sha, cRefA.get(0).hash);
	}
	
	@Test
	public void commitTicketBranchDeleteNoMergeReference() throws Exception {
		setPatchsetAvailable(false);

		TicketModel a = ticketService.createTicket(repo, newTicket("commitTicketBranchDeleteNoMergeReference-A"));
		TicketModel b = ticketService.createTicket(repo, newTicket("commitTicketBranchDeleteNoMergeReference-B"));
		TicketModel c = ticketService.createTicket(repo, newTicket("commitTicketBranchDeleteNoMergeReference-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);
		
		//Confirm that old invalid references removed for both tickets
		assertDeleteBranch(branchName);
		
		a = ticketService.getTicket(repo, a.number);
		b = ticketService.getTicket(repo, b.number);
		c = ticketService.getTicket(repo, c.number);
		assertFalse(a.hasReferences());
		assertFalse(b.hasReferences());
		assertFalse(c.hasReferences());
	}
	
	@Test
	public void commitTicketBranchDeletePostMergeReference() throws Exception {
		setPatchsetAvailable(false);

		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);
	}
	
	private static Change newComment(String text) {
		Change change = new Change("JUnit");
		change.comment(text);
		return change;
	}
	
	private static Change newTicket(String title) {
		Change change = new Change("JUnit");
		change.setField(Field.title, title);
		change.setField(Field.type, TicketModel.Type.Bug );
		return change;
	}
	
	private static RevCommit makeCommit(String message) throws Exception {
		File file = new File(workingCopy, "testFile.txt");
		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 rev = git.commit().setMessage(message).call();
		return rev;
	}
	
	private static String amendCommit(String message) throws Exception {
		File file = new File(workingCopy, "testFile.txt");
		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 rev = git.commit().setAmend(true).setMessage(message).call();
		return rev.getId().name();
	}
	
	
	private void setPatchsetAvailable(boolean state) throws GitBlitException {
		repo.acceptNewPatchsets = state;
		gitblit().updateRepositoryModel(repo.name, repo, false);
	}
	
	
	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());
		}
	}
	
	private void assertForcePushSuccess(String commitSha, String branchName) throws Exception {
		Iterable<PushResult> results = git.push().setForce(true).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());
		}
	}
	
	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());
		}
	}
}