EGit Core tests: fix PushOperation and add tests

While writing tests for EGit Core, the following problems with
PushOperation were identified: 
1. an operation result is returned even if the operation was not run before
2. when re-using he specification used to create the operation, the
operation result is completely wrong (says UP_TO_DATE and does
not update the remote repo even if it should)
These issues were fixed and corresponding tests
were added. 

Other tests for the 

1. ListRemoteOperation
2. TagOperation
3. TrackOperation
4. UntrackOperation
5. DiscardChangesOperation

were added along with some infrastructure for these
tests (which need to set up two repositories instead of just
one).

There were also some intermittent failures to delete resources
in GitResourceVariant* and BlotStorage tests. Hopfully the change there
will improve this.

Total test coverage for egit core improves from around 34 
percent to around 51 percent.

Bug: 318444

Change-Id: I80a79260666724ef3ebd5de097790a433049fee0
Signed-off-by: Mathias Kinzler <mathias.kinzler@sap.com>

13 files changed, 1000 insertions, 24 deletions

diff --git a/org.eclipse.egit.core.test/src/org/eclipse/egit/core/internal/storage/BlobStorageTest.java b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/internal/storage/BlobStorageTest.java
index e347116b10..ae612b683d 100644
--- a/org.eclipse.egit.core.test/src/org/eclipse/egit/core/internal/storage/BlobStorageTest.java
+++ b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/internal/storage/BlobStorageTest.java
@@ -33,6 +33,7 @@ public class BlobStorageTest extends GitTestCase {
 
 	@After
 	public void tearDown() throws Exception {
+		repository.close();
 		super.tearDown();
 	}
 
@@ -41,7 +42,7 @@ public class BlobStorageTest extends GitTestCase {
 		ObjectId id = createFile(repository, project.getProject(), "file", "data");
 		BlobStorage blobStorage = new BlobStorage(repository, "p/file", id);
 		assertEquals("file", blobStorage.getName());
-		assertEquals("data", slurpAndClose(blobStorage.getContents()));
+		assertEquals("data", testUtils.slurpAndClose(blobStorage.getContents()));
 		assertEquals(Path.fromPortableString("p/file").toOSString(), blobStorage.getFullPath().toOSString());
 
 	}
diff --git a/org.eclipse.egit.core.test/src/org/eclipse/egit/core/synchronize/GitResourceVariantComparatorTest.java b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/synchronize/GitResourceVariantComparatorTest.java
index 2628e2f58e..9b9db5e5eb 100644
--- a/org.eclipse.egit.core.test/src/org/eclipse/egit/core/synchronize/GitResourceVariantComparatorTest.java
+++ b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/synchronize/GitResourceVariantComparatorTest.java
@@ -34,6 +34,7 @@ import org.eclipse.egit.core.test.GitTestCase;
 import org.eclipse.jgit.lib.ObjectId;
 import org.eclipse.jgit.lib.Repository;
 import org.eclipse.team.core.variants.IResourceVariant;
+import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 
@@ -53,6 +54,12 @@ public class GitResourceVariantComparatorTest extends GitTestCase {
 		repo = RepositoryMapping.getMapping(iProject).getRepository();
 	}
 
+	@After
+	public void tearDown() throws Exception {
+		repo.close();
+		super.tearDown();
+	}
+
 	/*============================================
 	 * compare(IResource, IResourceVariant) tests
 	 *============================================*/
diff --git a/org.eclipse.egit.core.test/src/org/eclipse/egit/core/synchronize/GitResourceVariantTreeTest.java b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/synchronize/GitResourceVariantTreeTest.java
index c80bffb494..14c3a93771 100644
--- a/org.eclipse.egit.core.test/src/org/eclipse/egit/core/synchronize/GitResourceVariantTreeTest.java
+++ b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/synchronize/GitResourceVariantTreeTest.java
@@ -75,6 +75,7 @@ public class GitResourceVariantTreeTest extends GitTestCase {
 		new DisconnectProviderOperation(projects).execute(null);
 
 		repo.close();
+		super.tearDown();
 	}
 
 	/**
diff --git a/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/DualRepositoryTestCase.java b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/DualRepositoryTestCase.java
new file mode 100644
index 0000000000..d53c527a71
--- /dev/null
+++ b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/DualRepositoryTestCase.java
@@ -0,0 +1,46 @@
+/*******************************************************************************
+ * Copyright (C) 2010, Mathias Kinzler <mathias.kinzler@sap.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *******************************************************************************/
+package org.eclipse.egit.core.test;
+
+import java.io.File;
+
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IProjectDescription;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.Path;
+import org.eclipse.egit.core.op.ConnectProviderOperation;
+
+public abstract class DualRepositoryTestCase {
+
+	protected TestUtils testUtils = new TestUtils();
+
+	protected TestRepository repository1;
+
+	protected TestRepository repository2;
+
+	protected IProject testProject;
+
+	protected IProject importProject(TestRepository repo, String projectName)
+			throws Exception {
+		IProject firstProject = ResourcesPlugin.getWorkspace().getRoot()
+				.getProject(projectName);
+		if (firstProject.exists())
+			firstProject.delete(false, null);
+		IProjectDescription desc = ResourcesPlugin.getWorkspace()
+				.newProjectDescription(projectName);
+		File parentFile = repo.getRepository().getWorkDir();
+		desc.setLocation(new Path(new File(parentFile, projectName).getPath()));
+		firstProject.create(desc, null);
+		firstProject.open(null);
+		ConnectProviderOperation cop = new ConnectProviderOperation(
+				firstProject, repo.getRepository().getDirectory());
+		cop.execute(null);
+		return firstProject;
+	}
+}
diff --git a/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/GitTestCase.java b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/GitTestCase.java
index 6824e606c2..50a421cb7c 100644
--- a/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/GitTestCase.java
+++ b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/GitTestCase.java
@@ -12,7 +12,6 @@ import java.io.File;
 import java.io.FileOutputStream;
 import java.io.FileWriter;
 import java.io.IOException;
-import java.io.InputStream;
 
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.ResourcesPlugin;
@@ -29,6 +28,8 @@ import org.junit.Before;
 
 public abstract class GitTestCase {
 
+	protected final TestUtils testUtils = new TestUtils();
+
 	protected TestProject project;
 
 	protected File gitDir;
@@ -43,17 +44,17 @@ public abstract class GitTestCase {
 		project = new TestProject(true);
 		gitDir = new File(project.getProject().getWorkspace().getRoot()
 				.getRawLocation().toFile(), Constants.DOT_GIT);
-		TestUtils.rmrf(gitDir);
+		testUtils.deleteRecursive(gitDir);
 	}
 
 	@After
 	public void tearDown() throws Exception {
 		project.dispose();
-		TestUtils.rmrf(gitDir);
+		testUtils.deleteRecursive(gitDir);
 	}
 
-	protected ObjectId createFile(Repository repository, IProject project, String name, String content) throws IOException {
-		File file = new File(project.getProject().getLocation().toFile(), name);
+	protected ObjectId createFile(Repository repository, IProject actProject, String name, String content) throws IOException {
+		File file = new File(actProject.getProject().getLocation().toFile(), name);
 		FileWriter fileWriter = new FileWriter(file);
 		fileWriter.write(content);
 		fileWriter.close();
@@ -61,8 +62,8 @@ public abstract class GitTestCase {
 		return objectWriter.writeBlob(file);
 	}
 
-	protected ObjectId createFileCorruptShort(Repository repository, IProject project, String name, String content) throws IOException {
-		ObjectId id = createFile(repository, project, name, content);
+	protected ObjectId createFileCorruptShort(Repository repository, IProject actProject, String name, String content) throws IOException {
+		ObjectId id = createFile(repository, actProject, name, content);
 		File file = new File(repository.getDirectory(), "objects/" + id.name().substring(0,2) + "/" + id.name().substring(2));
 		byte[] readFully = IO.readFully(file);
 		file.delete();
@@ -80,17 +81,4 @@ public abstract class GitTestCase {
 		return objectWriter.writeTree(tree);
 	}
 
-	protected String slurpAndClose(InputStream inputStream) throws IOException {
-		StringBuilder stringBuilder = new StringBuilder();
-		try {
-			int ch;
-			while ((ch = inputStream.read()) != -1) {
-				stringBuilder.append((char)ch);
-			}
-		} finally {
-			inputStream.close();
-		}
-		return stringBuilder.toString();
-	}
-
 }
diff --git a/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/TestProject.java b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/TestProject.java
index a20c4b4a3f..2ec001411e 100644
--- a/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/TestProject.java
+++ b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/TestProject.java
@@ -40,6 +40,7 @@ public class TestProject {
 
 	private IPackageFragmentRoot sourceFolder;
 	private String location;
+	private TestUtils testUtils = new TestUtils();
 
 	/**
 	 * @throws CoreException
@@ -115,7 +116,7 @@ public class TestProject {
 		if (project.exists())
 			project.delete(true, true, null);
 		else
-			TestUtils.rmrf(new File(location));
+			testUtils.deleteRecursive(new File(location));
 	}
 
 	private IFolder createBinFolder() throws CoreException {
diff --git a/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/TestRepository.java b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/TestRepository.java
index 663b745fb2..6ab42936ba 100644
--- a/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/TestRepository.java
+++ b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/TestRepository.java
@@ -14,6 +14,9 @@ import java.io.File;
 import java.io.IOException;
 
 import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.egit.core.op.ConnectProviderOperation;
 import org.eclipse.jgit.api.CommitCommand;
 import org.eclipse.jgit.api.ConcurrentRefUpdateException;
 import org.eclipse.jgit.api.Git;
@@ -61,6 +64,23 @@ public class TestRepository {
 	}
 
 	/**
+	 * Creates a test repository from an existing Repository
+	 * @param repository
+	 * @throws IOException
+	 */
+	public TestRepository(Repository repository) throws IOException {
+		this.repository = repository;
+		try {
+			workdirPrefix = repository.getWorkDir().getCanonicalPath();
+		} catch (IOException err) {
+			workdirPrefix = repository.getWorkDir().getAbsolutePath();
+		}
+		workdirPrefix = workdirPrefix.replace('\\', '/');
+		if (!workdirPrefix.endsWith("/"))  //$NON-NLS-1$
+			workdirPrefix += "/";  //$NON-NLS-1$
+	}
+
+	/**
 	 * @return the wrapped repository
 	 */
 	public Repository getRepository() {
@@ -202,4 +222,15 @@ public class TestRepository {
 		repository.close();
 		repository = null;
 	}
+
+	/**
+	 * Connect a project to this repository
+	 * @param project
+	 * @throws CoreException
+	 */
+	public void connect(IProject project) throws CoreException {
+		ConnectProviderOperation op = new ConnectProviderOperation(project,
+				this.getRepository().getDirectory());
+		op.execute(null);
+	}
 }
diff --git a/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/TestUtils.java b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/TestUtils.java
index 487d86eaf3..3d3e1f59c6 100644
--- a/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/TestUtils.java
+++ b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/TestUtils.java
@@ -1,6 +1,7 @@
 /*******************************************************************************
  * Copyright (C) 2007, Robin Rosenberg <robin.rosenberg@dewire.com>
  * Copyright (C) 2010, Jens Baumgart <jens.baumgart@sap.com>
+ * Copyright (C) 2010, Mathias Kinzler <mathias.kinzler@sap.com>
  *
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
@@ -9,18 +10,35 @@
  *******************************************************************************/
 package org.eclipse.egit.core.test;
 
+import java.io.ByteArrayInputStream;
 import java.io.File;
 import java.io.IOException;
+import java.io.InputStream;
+
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IFolder;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IProjectDescription;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.Path;
+import org.eclipse.jgit.util.FS;
 
 public class TestUtils {
+
+	public final static String AUTHOR = "The Author <The.author@some.com>";
+
+	public final static String COMMITTER = "The Commiter <The.committer@some.com>";
+
 	/**
 	 * This method deletes a file / subtree
 	 *
 	 * @param d
 	 *            file / folder to delete
 	 * @throws IOException
+	 *             if file can not be deleted
 	 */
-	public static void rmrf(File d) throws IOException {
+	public void deleteRecursive(File d) throws IOException {
 		if (!d.exists())
 			return;
 
@@ -28,7 +46,7 @@ public class TestUtils {
 		if (files != null) {
 			for (int i = 0; i < files.length; ++i) {
 				if (files[i].isDirectory())
-					rmrf(files[i]);
+					deleteRecursive(files[i]);
 				else if (!files[i].delete())
 					throw new IOException(files[i] + " in use or undeletable");
 			}
@@ -38,4 +56,108 @@ public class TestUtils {
 		assert !d.exists();
 	}
 
+	/**
+	 * Create a "temporary" directory
+	 *
+	 * @param name
+	 *            the name of the directory
+	 * @return a directory as child of a "temporary" folder in the user home
+	 *         directory; may or may not exist
+	 * @throws IOException
+	 */
+	public File getTempDir(String name) throws IOException {
+		File userHome = FS.DETECTED.userHome();
+		File rootDir = new File(userHome, "EGitCoreTestTempDir");
+		File result = new File(rootDir, name);
+		if (result.exists())
+			deleteRecursive(result);
+		return result;
+	}
+
+	/**
+	 * Cleanup: delete the "temporary" folder and all children
+	 *
+	 * @throws IOException
+	 */
+	public void deleteTempDirs() throws IOException {
+		File userHome = FS.DETECTED.userHome();
+		File rootDir = new File(userHome, "EGitCoreTestTempDir");
+		if (rootDir.exists())
+			deleteRecursive(rootDir);
+	}
+
+	/**
+	 * Read the stream into a String
+	 *
+	 * @param inputStream
+	 * @return the contents of the stream
+	 * @throws IOException
+	 */
+	public String slurpAndClose(InputStream inputStream) throws IOException {
+		StringBuilder stringBuilder = new StringBuilder();
+		try {
+			int ch;
+			while ((ch = inputStream.read()) != -1) {
+				stringBuilder.append((char) ch);
+			}
+		} finally {
+			inputStream.close();
+		}
+		return stringBuilder.toString();
+	}
+
+	/**
+	 * Add a file to an existing project
+	 *
+	 * @param project
+	 *            the project
+	 * @param path
+	 *            e.g. "folder1/folder2/test.txt"
+	 * @param content
+	 *            the contents
+	 * @return the file
+	 * @throws Exception
+	 *             if the file can not be created
+	 */
+	public IFile addFileToProject(IProject project, String path, String content)
+			throws Exception {
+		IPath filePath = new Path(path);
+		IFolder folder = null;
+		for (int i = 0; i < filePath.segmentCount() - 1; i++) {
+			if (folder == null) {
+				folder = project.getFolder(filePath.segment(i));
+			} else {
+				folder = folder.getFolder(filePath.segment(i));
+			}
+			folder.create(false, true, null);
+		}
+		IFile file = project.getFile(filePath);
+		file.create(new ByteArrayInputStream(content.getBytes(project
+				.getDefaultCharset())), true, null);
+		return file;
+	}
+
+	/**
+	 * Create a project in the local file system
+	 *
+	 * @param parentFile
+	 *            the parent
+	 * @param projectName
+	 *            project name
+	 * @return the project with a location pointing to the local file system
+	 * @throws Exception
+	 */
+	public IProject createProjectInLocalFileSystem(File parentFile,
+			String projectName) throws Exception {
+		IProject firstProject = ResourcesPlugin.getWorkspace().getRoot()
+				.getProject(projectName);
+		if (firstProject.exists())
+			firstProject.delete(false, null);
+		IProjectDescription desc = ResourcesPlugin.getWorkspace()
+				.newProjectDescription(projectName);
+		desc.setLocation(new Path(new File(parentFile, projectName).getPath()));
+		firstProject.create(desc, null);
+		firstProject.open(null);
+		return firstProject;
+	}
 }
diff --git a/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/op/DiscardChangesOperationTest.java b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/op/DiscardChangesOperationTest.java
new file mode 100644
index 0000000000..5b2e60d271
--- /dev/null
+++ b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/op/DiscardChangesOperationTest.java
@@ -0,0 +1,104 @@
+/*******************************************************************************
+ * Copyright (C) 2010, Mathias Kinzler <mathias.kinzler@sap.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *******************************************************************************/
+package org.eclipse.egit.core.test.op;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.IOException;
+
+import org.eclipse.core.filesystem.EFS;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.IResourceVisitor;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.core.runtime.Path;
+import org.eclipse.egit.core.Activator;
+import org.eclipse.egit.core.op.DiscardChangesOperation;
+import org.eclipse.egit.core.test.DualRepositoryTestCase;
+import org.eclipse.egit.core.test.TestRepository;
+import org.eclipse.jgit.lib.Constants;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+public class DiscardChangesOperationTest extends DualRepositoryTestCase {
+
+	File workdir;
+
+	IProject project;
+
+	String projectName = "DiscardChangesTest";
+
+	@Before
+	public void setUp() throws Exception {
+
+		workdir = testUtils.getTempDir("Repository1");
+
+		repository1 = new TestRepository(new File(workdir, Constants.DOT_GIT));
+
+		// now we create a project in repo1
+		project = testUtils
+				.createProjectInLocalFileSystem(workdir, projectName);
+		testUtils.addFileToProject(project, "folder1/file1.txt", "Hello world");
+
+		repository1.connect(project);
+
+		project.accept(new IResourceVisitor() {
+
+			public boolean visit(IResource resource) throws CoreException {
+				if (resource instanceof IFile) {
+					try {
+						repository1
+								.track(EFS.getStore(resource.getLocationURI())
+										.toLocalFile(0, null));
+					} catch (IOException e) {
+						throw new CoreException(Activator.error(e.getMessage(),
+								e));
+					}
+				}
+				return true;
+			}
+		});
+		repository1.commit("Initial commit");
+	}
+
+	@After
+	public void tearDown() throws Exception {
+		project.close(null);
+		project.delete(false, false, null);
+		repository1.dispose();
+		repository1 = null;
+		testUtils.deleteRecursive(workdir);
+	}
+
+	@Test
+	public void testDiscardChanges() throws Exception {
+		IFile file = project.getFile(new Path("folder1/file1.txt"));
+		String contents = testUtils.slurpAndClose(file.getContents());
+		assertEquals("Hello world", contents);
+
+		file.setContents(new ByteArrayInputStream("Changed".getBytes(project
+				.getDefaultCharset())), 0, null);
+
+		contents = testUtils.slurpAndClose(file.getContents());
+		assertEquals("Changed", contents);
+
+		DiscardChangesOperation dcop = new DiscardChangesOperation(
+				new IResource[] { file });
+		dcop.execute(new NullProgressMonitor());
+
+		contents = testUtils.slurpAndClose(file.getContents());
+		assertEquals("Hello world", contents);
+
+	}
+}
diff --git a/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/op/ListRemoteOperationTest.java b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/op/ListRemoteOperationTest.java
new file mode 100644
index 0000000000..4b38e19ec3
--- /dev/null
+++ b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/op/ListRemoteOperationTest.java
@@ -0,0 +1,178 @@
+/*******************************************************************************
+ * Copyright (C) 2010, Mathias Kinzler <mathias.kinzler@sap.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *******************************************************************************/
+package org.eclipse.egit.core.test.op;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.fail;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+
+import org.eclipse.core.filesystem.EFS;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.IResourceVisitor;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.egit.core.Activator;
+import org.eclipse.egit.core.op.CloneOperation;
+import org.eclipse.egit.core.op.ListRemoteOperation;
+import org.eclipse.egit.core.test.DualRepositoryTestCase;
+import org.eclipse.egit.core.test.TestRepository;
+import org.eclipse.jgit.lib.Constants;
+import org.eclipse.jgit.lib.RefUpdate;
+import org.eclipse.jgit.lib.Repository;
+import org.eclipse.jgit.transport.URIish;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+public class ListRemoteOperationTest extends DualRepositoryTestCase {
+
+	File workdir;
+
+	File workdir2;
+
+	String projectName = "ListRemoteTest";
+
+	/**
+	 * Set up repository1 with branch "master", create some project and commit
+	 * it; then clone into repository2; finally create a branch "test" on top of
+	 * "master" in repository2
+	 *
+	 * @throws Exception
+	 */
+	@Before
+	public void setUp() throws Exception {
+
+		workdir = testUtils.getTempDir("Repository1");
+		workdir2 = testUtils.getTempDir("Repository2");
+
+		repository1 = new TestRepository(new File(workdir, Constants.DOT_GIT));
+
+		// now we create a project in repo1
+		IProject project = testUtils.createProjectInLocalFileSystem(workdir,
+				projectName);
+		testUtils.addFileToProject(project, "folder1/file1.txt", "Hello world");
+
+		repository1.connect(project);
+
+		project.accept(new IResourceVisitor() {
+
+			public boolean visit(IResource resource) throws CoreException {
+				if (resource instanceof IFile) {
+					try {
+						repository1
+								.track(EFS.getStore(resource.getLocationURI())
+										.toLocalFile(0, null));
+					} catch (IOException e) {
+						throw new CoreException(Activator.error(e.getMessage(),
+								e));
+					}
+				}
+				return true;
+			}
+		});
+
+		repository1.commit("Initial commit");
+
+		// let's get rid of the project
+		project.delete(false, false, null);
+
+		// let's clone repository1 to repository2
+		URIish uri = new URIish("file:///"
+				+ repository1.getRepository().getDirectory().toString());
+		CloneOperation clop = new CloneOperation(uri, true, null, workdir2,
+				"refs/heads/master", "origin");
+		clop.run(null);
+
+		repository2 = new TestRepository(new Repository(new File(workdir2,
+				Constants.DOT_GIT)));
+		// we push to branch "test" of repository2
+		RefUpdate createBranch = repository2.getRepository().updateRef(
+				"refs/heads/test");
+		createBranch.setNewObjectId(repository2.getRepository().resolve(
+				"refs/heads/master"));
+		createBranch.update();
+	}
+
+	@After
+	public void tearDown() throws Exception {
+		repository1.dispose();
+		repository2.dispose();
+		testUtils.deleteRecursive(workdir);
+		testUtils.deleteRecursive(workdir2);
+	}
+
+	/**
+	 * List the refs both ways
+	 *
+	 * @throws Exception
+	 */
+	@Test
+	public void testListRemote() throws Exception {
+
+		URIish uri = new URIish("file:///"
+				+ repository2.getRepository().getDirectory().getPath());
+		ListRemoteOperation lrop = new ListRemoteOperation(repository1
+				.getRepository(), uri);
+		lrop.run(null);
+		assertEquals(4, lrop.getRemoteRefs().size());
+		assertNotNull(lrop.getRemoteRef("refs/heads/test"));
+
+		uri = new URIish("file:///"
+				+ repository1.getRepository().getDirectory().getPath());
+		lrop = new ListRemoteOperation(repository2.getRepository(), uri);
+		lrop.run(new NullProgressMonitor());
+		assertEquals(2, lrop.getRemoteRefs().size());
+		assertNotNull(lrop.getRemoteRef("refs/heads/master"));
+	}
+
+	/**
+	 * Call getRemoteRefs without having run the op
+	 *
+	 * @throws Exception
+	 */
+	@Test
+	public void testIllegalStateException() throws Exception {
+
+		URIish uri = new URIish("file:///"
+				+ repository2.getRepository().getDirectory().getPath());
+		ListRemoteOperation lrop = new ListRemoteOperation(repository1
+				.getRepository(), uri);
+		try {
+			lrop.getRemoteRefs();
+			fail("Expected Exception not thrown");
+		} catch (IllegalStateException e) {
+			// expected
+		}
+	}
+
+	/**
+	 * Test with illegal URI
+	 *
+	 * @throws Exception
+	 */
+	@Test
+	public void testIllegalURI() throws Exception {
+
+		URIish uri = new URIish("file:///" + "no/path");
+		ListRemoteOperation lrop = new ListRemoteOperation(repository1
+				.getRepository(), uri);
+		try {
+			lrop.run(new NullProgressMonitor());
+			fail("Expected Exception not thrown");
+		} catch (InvocationTargetException e) {
+			// expected
+		}
+	}
+}
diff --git a/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/op/PushOperationTest.java b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/op/PushOperationTest.java
new file mode 100644
index 0000000000..48fa2d134d
--- /dev/null
+++ b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/op/PushOperationTest.java
@@ -0,0 +1,264 @@
+/*******************************************************************************
+ * Copyright (C) 2010, Mathias Kinzler <mathias.kinzler@sap.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *******************************************************************************/
+package org.eclipse.egit.core.test.op;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.eclipse.core.filesystem.EFS;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.IResourceVisitor;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.egit.core.Activator;
+import org.eclipse.egit.core.op.BranchOperation;
+import org.eclipse.egit.core.op.CloneOperation;
+import org.eclipse.egit.core.op.CommitOperation;
+import org.eclipse.egit.core.op.PushOperation;
+import org.eclipse.egit.core.op.PushOperationResult;
+import org.eclipse.egit.core.op.PushOperationSpecification;
+import org.eclipse.egit.core.op.TrackOperation;
+import org.eclipse.egit.core.test.DualRepositoryTestCase;
+import org.eclipse.egit.core.test.TestRepository;
+import org.eclipse.egit.core.test.TestUtils;
+import org.eclipse.jgit.lib.Constants;
+import org.eclipse.jgit.lib.RefUpdate;
+import org.eclipse.jgit.lib.Repository;
+import org.eclipse.jgit.transport.RemoteRefUpdate;
+import org.eclipse.jgit.transport.URIish;
+import org.eclipse.jgit.transport.RemoteRefUpdate.Status;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+public class PushOperationTest extends DualRepositoryTestCase {
+
+	File workdir;
+
+	File workdir2;
+
+	String projectName = "PushTest";
+
+	/**
+	 * Set up repository1 with branch "master", create some project and commit
+	 * it; then clone into repository2; finally create a branch "test" on top of
+	 * "master" in repository2
+	 *
+	 * @throws Exception
+	 */
+	@Before
+	public void setUp() throws Exception {
+
+		workdir = testUtils.getTempDir("Repository1");
+		workdir2 = testUtils.getTempDir("Repository2");
+
+		repository1 = new TestRepository(new File(workdir, Constants.DOT_GIT));
+
+		// now we create a project in repo1
+		IProject project = testUtils.createProjectInLocalFileSystem(workdir,
+				projectName);
+		testUtils.addFileToProject(project, "folder1/file1.txt", "Hello world");
+
+		repository1.connect(project);
+
+		project.accept(new IResourceVisitor() {
+
+			public boolean visit(IResource resource) throws CoreException {
+				if (resource instanceof IFile) {
+					try {
+						repository1
+								.track(EFS.getStore(resource.getLocationURI())
+										.toLocalFile(0, null));
+					} catch (IOException e) {
+						throw new CoreException(Activator.error(e.getMessage(),
+								e));
+					}
+				}
+				return true;
+			}
+		});
+
+		repository1.commit("Initial commit");
+
+		// let's get rid of the project
+		project.delete(false, false, null);
+
+		// let's clone repository1 to repository2
+		URIish uri = new URIish("file:///"
+				+ repository1.getRepository().getDirectory().toString());
+		CloneOperation clop = new CloneOperation(uri, true, null, workdir2,
+				"refs/heads/master", "origin");
+		clop.run(null);
+
+		repository2 = new TestRepository(new Repository(new File(workdir2,
+				Constants.DOT_GIT)));
+		// we push to branch "test" of repository2
+		RefUpdate createBranch = repository2.getRepository().updateRef(
+				"refs/heads/test");
+		createBranch.setNewObjectId(repository2.getRepository().resolve(
+				"refs/heads/master"));
+		createBranch.update();
+	}
+
+	@After
+	public void tearDown() throws Exception {
+		repository1.dispose();
+		repository2.dispose();
+		repository1 = null;
+		repository2 = null;
+		testUtils.deleteRecursive(workdir);
+		testUtils.deleteRecursive(workdir2);
+	}
+
+	/**
+	 * Push from repository1 "master" into "test" of repository2.
+	 *
+	 * @throws Exception
+	 */
+	@Test
+	public void testPush() throws Exception {
+
+		// push from repository1 to repository2
+		PushOperation pop = createPushOperation();
+		pop.run(new NullProgressMonitor());
+		assertEquals(Status.UP_TO_DATE, getStatus(pop.getOperationResult()));
+
+		// let's add a new file to the project shared with repository1
+		IProject proj = importProject(repository1, projectName);
+		ArrayList<IFile> files = new ArrayList<IFile>();
+		IFile newFile = testUtils.addFileToProject(proj, "folder2/file2.txt",
+				"New file");
+		files.add(newFile);
+		IFile[] fileArr = files.toArray(new IFile[files.size()]);
+
+		TrackOperation trop = new TrackOperation(fileArr);
+		trop.execute(null);
+		CommitOperation cop = new CommitOperation(fileArr, files, files,
+				TestUtils.AUTHOR, TestUtils.COMMITTER, "Added file");
+		cop.execute(null);
+
+		proj.delete(false, false, null);
+
+		pop = createPushOperation();
+		pop.run(null);
+		assertEquals(Status.OK, getStatus(pop.getOperationResult()));
+
+		try {
+			// assert that we can not run this again
+			pop.run(null);
+			fail("Expected Exception not thrown");
+		} catch (IllegalStateException e) {
+			// expected
+		}
+
+		pop = createPushOperation();
+		pop.run(null);
+		assertEquals(Status.UP_TO_DATE, getStatus(pop.getOperationResult()));
+
+		String newFilePath = newFile.getFullPath().toOSString();
+
+		File testFile = new File(workdir2, newFilePath);
+		assertFalse(testFile.exists());
+		testFile = new File(workdir, newFilePath);
+		assertTrue(testFile.exists());
+
+		// check out test and verify the file is there
+		BranchOperation bop = new BranchOperation(repository2.getRepository(),
+				"refs/heads/test");
+		bop.execute(null);
+		testFile = new File(workdir2, newFilePath);
+		assertTrue(testFile.exists());
+	}
+
+	/**
+	 * We should get an {@link IllegalStateException} if we run
+	 * getOperationResult before run()
+	 *
+	 * @throws Exception
+	 */
+	@Test
+	public void testIllegalStateExceptionOnGetResultWithoutRun()
+			throws Exception {
+		// push from repository1 to repository2
+		PushOperation pop = createPushOperation();
+		try {
+			pop.getOperationResult();
+			fail("Expected Exception not thrown");
+		} catch (IllegalStateException e) {
+			// expected
+		}
+	}
+
+	/**
+	 * We should get an {@link IllegalStateException} if the spec was re-used
+	 *
+	 * @throws Exception
+	 */
+	@Test
+	public void testPushWithReusedSpec() throws Exception {
+
+		PushOperationSpecification spec = new PushOperationSpecification();
+		// the remote is repo2
+		URIish remote = new URIish("file:///"
+				+ repository2.getRepository().getDirectory().toString());
+		// update master upon master
+		List<RemoteRefUpdate> refUpdates = new ArrayList<RemoteRefUpdate>();
+		RemoteRefUpdate update = new RemoteRefUpdate(repository1
+				.getRepository(), "HEAD", "refs/heads/test", false, null, null);
+		refUpdates.add(update);
+		spec.addURIRefUpdates(remote, refUpdates);
+
+		PushOperation pop = new PushOperation(repository1.getRepository(),
+				spec, false, null);
+		pop.run(null);
+
+		pop = new PushOperation(repository1.getRepository(), spec, false, null);
+		try {
+			pop.run(null);
+			fail("Expected Exception not thrown");
+		} catch (IllegalStateException e) {
+			// expected
+		}
+	}
+
+	private Status getStatus(PushOperationResult operationResult) {
+		URIish uri = operationResult.getURIs().iterator().next();
+		return operationResult.getPushResult(uri).getRemoteUpdates().iterator()
+				.next().getStatus();
+	}
+
+	private PushOperation createPushOperation() throws Exception {
+		// set up push from repository1 to repository2
+		// we can not re-use the RemoteRefUpdate!!!
+		PushOperationSpecification spec = new PushOperationSpecification();
+		// the remote is repo2
+		URIish remote = new URIish("file:///"
+				+ repository2.getRepository().getDirectory().toString());
+		// update master upon master
+		List<RemoteRefUpdate> refUpdates = new ArrayList<RemoteRefUpdate>();
+		RemoteRefUpdate update = new RemoteRefUpdate(repository1
+				.getRepository(), "HEAD", "refs/heads/test", false, null, null);
+		refUpdates.add(update);
+		spec.addURIRefUpdates(remote, refUpdates);
+		// now we can construct the push operation
+		PushOperation pop = new PushOperation(repository1.getRepository(),
+				spec, false, null);
+		return pop;
+	}
+
+}
diff --git a/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/op/TagOperationTest.java b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/op/TagOperationTest.java
new file mode 100644
index 0000000000..7abc2c9dde
--- /dev/null
+++ b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/op/TagOperationTest.java
@@ -0,0 +1,114 @@
+package org.eclipse.egit.core.test.op;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.io.File;
+import java.io.IOException;
+
+import org.eclipse.core.filesystem.EFS;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.IResourceVisitor;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.egit.core.Activator;
+import org.eclipse.egit.core.op.TagOperation;
+import org.eclipse.egit.core.test.DualRepositoryTestCase;
+import org.eclipse.egit.core.test.TestRepository;
+import org.eclipse.egit.core.test.TestUtils;
+import org.eclipse.jgit.lib.Constants;
+import org.eclipse.jgit.lib.PersonIdent;
+import org.eclipse.jgit.lib.Ref;
+import org.eclipse.jgit.lib.Tag;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+public class TagOperationTest extends DualRepositoryTestCase {
+
+	File workdir;
+
+	String projectName = "TagTest";
+
+	@Before
+	public void setUp() throws Exception {
+
+		workdir = testUtils.getTempDir("Repository1");
+
+		repository1 = new TestRepository(new File(workdir, Constants.DOT_GIT));
+
+		// now we create a project in repo1
+		IProject project = testUtils.createProjectInLocalFileSystem(workdir,
+				projectName);
+		testUtils.addFileToProject(project, "folder1/file1.txt", "Hello world");
+
+		repository1.connect(project);
+
+		project.accept(new IResourceVisitor() {
+
+			public boolean visit(IResource resource) throws CoreException {
+				if (resource instanceof IFile) {
+					try {
+						repository1
+								.track(EFS.getStore(resource.getLocationURI())
+										.toLocalFile(0, null));
+					} catch (IOException e) {
+						throw new CoreException(Activator.error(e.getMessage(),
+								e));
+					}
+				}
+				return true;
+			}
+		});
+
+		repository1.commit("Initial commit");
+	}
+
+	@After
+	public void tearDown() throws Exception {
+		repository1.dispose();
+		repository1 = null;
+		testUtils.deleteRecursive(workdir);
+	}
+
+	@Test
+	public void addTag() throws Exception {
+		assertTrue("Tags should be empty", repository1.getRepository().getTags().isEmpty());
+		Tag newTag = new Tag(repository1.getRepository());
+		newTag.setTag("TheNewTag");
+		newTag.setMessage("Well, I'm the tag");
+		newTag.setAuthor(new PersonIdent(TestUtils.AUTHOR));
+		newTag.setObjId(repository1.getRepository().resolve("refs/heads/master"));
+		TagOperation top = new TagOperation(repository1.getRepository(), newTag, false);
+		top.execute(new NullProgressMonitor());
+		assertFalse("Tags should not be empty", repository1.getRepository().getTags().isEmpty());
+
+		try {
+			top.execute(null);
+			fail("Expected Exception not thrown");
+		} catch (CoreException e) {
+			// expected
+		}
+
+		top = new TagOperation(repository1.getRepository(), newTag, true);
+		try {
+			top.execute(null);
+			fail("Expected Exception not thrown");
+		} catch (CoreException e) {
+			// expected
+		}
+		Ref tagRef = repository1.getRepository().getTags().get("TheNewTag");
+		Tag tag = repository1.getRepository().mapTag(tagRef.getName());
+		newTag.setMessage("Another message");
+		assertFalse("Messages should differ", tag.getMessage().equals(
+				newTag.getMessage()));
+		top.execute(null);
+		tag = repository1.getRepository().mapTag(tagRef.getName());
+		assertTrue("Messages be same", tag.getMessage().equals(
+				newTag.getMessage()));
+	}
+
+}
diff --git a/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/op/TrackUntrackOperationTest.java b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/op/TrackUntrackOperationTest.java
new file mode 100644
index 0000000000..ce6635f2f3
--- /dev/null
+++ b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/op/TrackUntrackOperationTest.java
@@ -0,0 +1,119 @@
+/*******************************************************************************
+ * Copyright (C) 2010, Mathias Kinzler <mathias.kinzler@sap.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *******************************************************************************/
+package org.eclipse.egit.core.test.op;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+import org.eclipse.core.resources.IContainer;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.IResourceVisitor;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.egit.core.op.TrackOperation;
+import org.eclipse.egit.core.op.UntrackOperation;
+import org.eclipse.egit.core.test.DualRepositoryTestCase;
+import org.eclipse.egit.core.test.TestRepository;
+import org.eclipse.jgit.dircache.DirCache;
+import org.eclipse.jgit.lib.Constants;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+public class TrackUntrackOperationTest extends DualRepositoryTestCase {
+
+	File workdir;
+
+	IProject project;
+
+	String projectName = "TrackTest";
+
+	@Before
+	public void setUp() throws Exception {
+
+		workdir = testUtils.getTempDir("Repository1");
+
+		repository1 = new TestRepository(new File(workdir, Constants.DOT_GIT));
+
+		// now we create a project in repo1
+		project = testUtils
+				.createProjectInLocalFileSystem(workdir, projectName);
+		testUtils.addFileToProject(project, "folder1/file1.txt", "Hello world");
+
+		repository1.connect(project);
+	}
+
+	@After
+	public void tearDown() throws Exception {
+		project.close(null);
+		project.delete(false, false, null);
+		repository1.dispose();
+		repository1 = null;
+		testUtils.deleteRecursive(workdir);
+	}
+
+	@Test
+	public void testTrackFiles() throws Exception {
+
+		final ArrayList<IFile> files = new ArrayList<IFile>();
+
+		DirCache cache = DirCache.read(repository1.getRepository());
+		assertEquals("Wrong cache entry count", 0, cache.getEntryCount());
+
+		project.accept(new IResourceVisitor() {
+
+			public boolean visit(IResource resource) throws CoreException {
+				if (resource instanceof IFile)
+					files.add((IFile) resource);
+				return true;
+			}
+		});
+
+		IFile[] fileArr = files.toArray(new IFile[files.size()]);
+
+		TrackOperation trop = new TrackOperation(fileArr);
+		trop.execute(new NullProgressMonitor());
+
+		cache.read();
+		assertEquals("Wrong cache entry count", 2, cache.getEntryCount());
+
+		UntrackOperation utop = new UntrackOperation(Arrays.asList(fileArr));
+		utop.execute(new NullProgressMonitor());
+
+		cache.read();
+		assertEquals("Wrong cache entry count", 0, cache.getEntryCount());
+
+	}
+
+	@Test
+	public void testTrackProject() throws Exception {
+
+		final ArrayList<IContainer> containers = new ArrayList<IContainer>();
+		containers.add(project);
+
+		DirCache cache = DirCache.read(repository1.getRepository());
+
+		assertEquals("Wrong cache entry count", 0, cache.getEntryCount());
+
+		IContainer[] fileArr = containers.toArray(new IContainer[containers
+				.size()]);
+
+		TrackOperation trop = new TrackOperation(fileArr);
+		trop.execute(new NullProgressMonitor());
+
+		cache.read();
+		assertEquals("Wrong cache entry count", 2, cache.getEntryCount());
+	}
+
+}