tests/org.eclipse.emf.emfstore.client.api.test/src/org/eclipse/emf/emfstore/client/api/test/SharedProjectTest.java - emf-store/org.eclipse.emf.emfstore.core - Git at Google

 /*******************************************************************************
  * Copyright (c) 2012-2013 EclipseSource Muenchen GmbH and others.
  *
  * 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
  *
  * Contributors:
  ******************************************************************************/
 package org.eclipse.emf.emfstore.client.api.test;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNotSame;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;

 import java.io.File;
 import java.io.IOException;
 import java.util.List;
 import java.util.concurrent.Callable;

 import org.apache.commons.io.FileUtils;
 import org.eclipse.core.runtime.NullProgressMonitor;
 import org.eclipse.emf.common.util.URI;
 import org.eclipse.emf.ecore.resource.Resource;
 import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
 import org.eclipse.emf.emfstore.bowling.BowlingFactory;
 import org.eclipse.emf.emfstore.bowling.League;
 import org.eclipse.emf.emfstore.bowling.Player;
 import org.eclipse.emf.emfstore.bowling.Tournament;
 import org.eclipse.emf.emfstore.client.ESLocalProject;
 import org.eclipse.emf.emfstore.client.ESRemoteProject;
 import org.eclipse.emf.emfstore.client.ESUsersession;
 import org.eclipse.emf.emfstore.client.ESWorkspaceProvider;
 import org.eclipse.emf.emfstore.client.callbacks.ESCommitCallback;
 import org.eclipse.emf.emfstore.client.test.common.cases.ESTestWithSharedProject;
 import org.eclipse.emf.emfstore.client.test.common.dsl.Add;
 import org.eclipse.emf.emfstore.client.test.common.dsl.Create;
 import org.eclipse.emf.emfstore.client.test.common.util.CommitCallbackAdapter;
 import org.eclipse.emf.emfstore.client.test.common.util.ProjectUtil;
 import org.eclipse.emf.emfstore.client.util.RunESCommand;
 import org.eclipse.emf.emfstore.common.model.ESModelElementId;
 import org.eclipse.emf.emfstore.common.model.ESModelElementIdFactory;
 import org.eclipse.emf.emfstore.internal.client.model.Workspace;
 import org.eclipse.emf.emfstore.internal.client.model.impl.api.ESWorkspaceImpl;
 import org.eclipse.emf.emfstore.internal.common.model.util.ModelUtil;
 import org.eclipse.emf.emfstore.server.exceptions.ESException;
 import org.eclipse.emf.emfstore.server.exceptions.ESUpdateRequiredException;
 import org.eclipse.emf.emfstore.server.model.ESBranchInfo;
 import org.eclipse.emf.emfstore.server.model.ESHistoryInfo;
 import org.eclipse.emf.emfstore.server.model.query.ESHistoryQuery;
 import org.eclipse.emf.emfstore.server.model.query.ESRangeQuery;
 import org.eclipse.emf.emfstore.server.model.versionspec.ESBranchVersionSpec;
 import org.eclipse.emf.emfstore.server.model.versionspec.ESPrimaryVersionSpec;
 import org.eclipse.emf.emfstore.server.model.versionspec.ESVersionSpec;
 import org.junit.After;
 import org.junit.AfterClass;
 import org.junit.BeforeClass;
 import org.junit.Ignore;
 import org.junit.Test;

 public class SharedProjectTest extends ESTestWithSharedProject {

 	private static final String SECOND_TEST_PROJECT_NAME = "SecondTestProject"; //$NON-NLS-1$
 	private static final String CHECKOUT_NAME = "testCheckout"; //$NON-NLS-1$
 	private static final String NEW_BRANCH_NAME = "newBranch"; //$NON-NLS-1$
 	private static final String COMMIT_MESSAGE = "SomeCommitMessage"; //$NON-NLS-1$
 	private static File tempFile;

 	private ESCommitCallback callback;
 	private boolean noLocalChangesOccurred;

 	@BeforeClass
 	public static void beforeClass() {
 		startEMFStore();
 	}

 	@AfterClass
 	public static void afterClass() {
 		stopEMFStore();
 	}

 	@After
 	@Override
 	public void after() {
 		if (tempFile != null) {
 			FileUtils.deleteQuietly(tempFile);
 			tempFile = null;
 		}
 		super.after();
 	}

 	@Test
 	public void testShare() {
 		try {
 			final ESRemoteProject remoteProject = getLocalProject().getRemoteProject();
 			assertNotNull(remoteProject);
 			assertTrue(getLocalProject().isShared());
 		} catch (final ESException e) {
 			fail(e.getMessage());
 		}
 	}

 	@Ignore
 	@Test
 	public void testShareAfterRemoteProjectHasBeenDeleted() {
 		try {
 			final ESRemoteProject remoteProject = getLocalProject().getRemoteProject();
 			assertNotNull(remoteProject);
 			remoteProject.delete(new NullProgressMonitor());
 			final ESUsersession session = getLocalProject().getUsersession();
 			session.logout();
 			session.refresh();
 			assertFalse(getLocalProject().isShared());
 		} catch (final ESException e) {
 			fail(e.getMessage());
 		}
 	}

 	@Test
 	public void testCommit() {
 		try {
 			final ESPrimaryVersionSpec base = getLocalProject().getBaseVersion();
 			Add.toProject(getLocalProject(), Create.player());
 			final ESPrimaryVersionSpec head = getLocalProject().commit(new NullProgressMonitor());
 			assertNotSame(base, head);
 		} catch (final ESException e) {
 			fail(e.getMessage());
 		}
 	}

 	@Test
 	public void testContains() {
 		final Player player = Create.player();
 		Add.toProject(getLocalProject(), player);
 		final ESModelElementId id = getLocalProject().getModelElementId(player);
 		final ESModelElementId clonedId = ESModelElementIdFactory.fromString(id.getId());
 		assertTrue(getLocalProject().contains(player));
 		assertTrue(getLocalProject().contains(id));
 		assertTrue(getLocalProject().contains(clonedId));
 	}

 	public void testCommitWithoutChange() throws ESException {
 		getLocalProject().commit(null, new CommitCallbackAdapter() {
 			@Override
 			public void noLocalChanges(ESLocalProject projectSpace) {
 				noLocalChangesOccurred = true;
 			}
 		}, new NullProgressMonitor());
 		assertTrue(noLocalChangesOccurred);
 	}

 	@Test
 	public void testCommitLog() {

 		try {
 			final ESPrimaryVersionSpec base = getLocalProject().getBaseVersion();
 			Add.toProject(getLocalProject(), Create.player());
 			final ESPrimaryVersionSpec head = getLocalProject().commit(COMMIT_MESSAGE, callback,
 				new NullProgressMonitor());
 			assertNotSame(base, head);
 		} catch (final ESException e) {
 			fail(e.getMessage());
 		}
 	}

 	@Test
 	public void testCommitBranch() {

 		try {
 			final ESPrimaryVersionSpec base = getLocalProject().getBaseVersion();
 			Add.toProject(getLocalProject(), Create.player());
 			final ESBranchVersionSpec branch = ESVersionSpec.FACTORY.createBRANCH(NEW_BRANCH_NAME);
 			final ESPrimaryVersionSpec head = getLocalProject().commitToBranch(branch, COMMIT_MESSAGE, callback,
 				new NullProgressMonitor());
 			assertNotSame(base, head);
 		} catch (final ESException e) {
 			fail(e.getMessage());
 		}
 	}

 	public void testCommitBranchWithoutChange() throws ESException {
 		final ESBranchVersionSpec branch = ESVersionSpec.FACTORY.createBRANCH(NEW_BRANCH_NAME);
 		getLocalProject().commitToBranch(branch, COMMIT_MESSAGE, new CommitCallbackAdapter() {
 			@Override
 			public void noLocalChanges(ESLocalProject projectSpace) {
 				noLocalChangesOccurred = true;
 			}
 		}, new NullProgressMonitor());
 		assertTrue(noLocalChangesOccurred);
 	}

 	@Test
 	public void testBranchesOnlyTrunk() {
 		try {
 			final List<? extends ESBranchInfo> branches = getLocalProject().getBranches(new NullProgressMonitor());
 			assertEquals(1, branches.size());
 			// TODO assert branch name
 		} catch (final ESException e) {
 			fail(e.getMessage());
 		}
 	}

 	@Test
 	public void testBranches() {

 		try {
 			List<? extends ESBranchInfo> branches = getLocalProject().getBranches(new NullProgressMonitor());
 			assertEquals(1, branches.size());

 			Add.toProject(getLocalProject(), Create.player());

 			final ESBranchVersionSpec branch = ESVersionSpec.FACTORY.createBRANCH(NEW_BRANCH_NAME);
 			getLocalProject().commitToBranch(branch, COMMIT_MESSAGE, callback,
 				new NullProgressMonitor());
 			branches = getLocalProject().getBranches(new NullProgressMonitor());
 			assertEquals(2, branches.size());
 			// TODO assert branch names
 		} catch (final ESException e) {
 			fail(e.getMessage());
 		}
 	}

 	@Test
 	public void testHistoryInfoOnlyTrunk() {
 		try {
 			final ESRangeQuery<?> query = ESHistoryQuery.FACTORY.rangeQuery(getLocalProject().getBaseVersion(), 1, 1,
 				true,
 				true,
 				true,
 				true);
 			final NullProgressMonitor monitor = new NullProgressMonitor();
 			List<ESHistoryInfo> infos = getLocalProject().getHistoryInfos(query, monitor);
 			assertEquals(1, infos.size());

 			Add.toProject(getLocalProject(), Create.player());

 			assertEquals(0, getLocalProject().getBaseVersion().getIdentifier());
 			final ESPrimaryVersionSpec head = getLocalProject().commit(COMMIT_MESSAGE, callback,
 				new NullProgressMonitor());
 			assertEquals(1, getLocalProject().getBaseVersion().getIdentifier());
 			infos = getLocalProject().getHistoryInfos(
 				ESHistoryQuery.FACTORY.rangeQuery(head, 1, 1, true, true, true, true),
 				monitor);
 			assertEquals(2, infos.size());
 			// TODO assert infos
 		} catch (final ESException e) {
 			fail(e.getMessage());
 		}
 	}

 	@Test
 	public void testHistoryInfoBranch() {
 		try {
 			final ESRangeQuery<?> query = ESHistoryQuery.FACTORY.rangeQuery(getLocalProject().getBaseVersion(), 1, 1,
 				true,
 				true,
 				true,
 				true);
 			final NullProgressMonitor monitor = new NullProgressMonitor();

 			List<ESHistoryInfo> infos = getLocalProject().getHistoryInfos(query, monitor);
 			assertEquals(1, infos.size());

 			Add.toProject(getLocalProject(), Create.player());
 			final ESBranchVersionSpec branch = ESVersionSpec.FACTORY.createBRANCH(NEW_BRANCH_NAME);
 			getLocalProject().commitToBranch(branch, COMMIT_MESSAGE, callback,
 				new NullProgressMonitor());
 			infos = getLocalProject().getHistoryInfos(query, monitor);
 			assertEquals(2, infos.size());
 			// TODO assert infos
 		} catch (final ESException e) {
 			fail(e.getMessage());
 		}
 	}

 	@Test
 	public void testHasUncommitedChanges() {
 		assertFalse(getLocalProject().hasUncommitedChanges());
 		Add.toProject(getLocalProject(), Create.player());
 		assertTrue(getLocalProject().hasUncommitedChanges());
 		try {
 			getLocalProject().commit(COMMIT_MESSAGE, callback, new NullProgressMonitor());
 		} catch (final ESException e) {
 			fail(e.getMessage());
 		}
 		assertFalse(getLocalProject().hasUncommitedChanges());

 	}

 	@Test(expected = ESUpdateRequiredException.class)
 	public void testMergeAndExpectBaseVersionOutOfDateException() throws ESException {
 		final NullProgressMonitor monitor = new NullProgressMonitor();
 		final Player player = Create.player();
 		Add.toProject(getLocalProject(), player);
 		getLocalProject().commit(monitor);
 		final ESLocalProject checkedoutCopy = getLocalProject().getRemoteProject().checkout(CHECKOUT_NAME, monitor);
 		final Player checkedoutPlayer = (Player) checkedoutCopy.getModelElements().get(0);

 		RunESCommand.run(new Callable<Void>() {
 			public Void call() throws Exception {
 				player.setName("A"); //$NON-NLS-1$
 				return null;
 			}
 		});

 		getLocalProject().commit(monitor);

 		RunESCommand.run(new Callable<Void>() {
 			public Void call() throws Exception {
 				checkedoutPlayer.setName("B"); //$NON-NLS-1$
 				return null;
 			}
 		});

 		checkedoutCopy.commit(monitor);
 	}

 	@Test
 	public void testMoveElementViaReference() throws ESException {

 		final League league = Create.league("Canadian bowling league"); //$NON-NLS-1$
 		final Player player = Create.player("Joe"); //$NON-NLS-1$
 		RunESCommand.run(new Callable<Void>() {
 			public Void call() throws Exception {
 				league.getPlayers().add(player);
 				getLocalProject().getModelElements().add(league);
 				return null;
 			}
 		});
 		assertTrue(getLocalProject().contains(league));

 		final ESLocalProject secondProject = getWorkspace().createLocalProject(SECOND_TEST_PROJECT_NAME);
 		secondProject.shareProject(new NullProgressMonitor());

 		// tournament does not contain players
 		final Tournament tournament = Create.tournament(false);
 		RunESCommand.run(new Callable<Void>() {
 			public Void call() throws Exception {
 				secondProject.getModelElements().add(tournament);
 				tournament.getPlayers().add(player);
 				return null;
 			}
 		});

 		getLocalProject().save();
 		secondProject.save();

 		assertTrue(secondProject.contains(player));
 		stopEMFStore();
 		startEMFStore();

 		for (final ESLocalProject project : ESWorkspaceProvider.INSTANCE.getWorkspace().getLocalProjects()) {
 			if (project.getProjectName().equals(SECOND_TEST_PROJECT_NAME)) {
 				final Tournament t = (Tournament) project.getModelElements().get(0);
 				assertEquals(t.getPlayers().size(), 1);
 			}
 		}
 	}

 	@Test
 	public void testShareWithModelInExistingResource() throws IOException, ESException {
 		final Resource resource = createResource();
 		final League league = createLeague();
 		resource.getContents().add(league);
 		resource.save(ModelUtil.getResourceSaveOptions());

 		final ESLocalProject project = ESWorkspaceProvider.INSTANCE.getWorkspace().createLocalProject("test"); //$NON-NLS-1$
 		ProjectUtil.addElement(project, league);
 		project.shareProject(getUsersession(), new NullProgressMonitor());

 		assertTrue(project.isShared());
 	}

 	@Test
 	public void testDeleteESUsersession() throws ESException {
 		final Workspace w = ESWorkspaceImpl.class.cast(getWorkspace()).toInternalAPI();
 		final int size = w.getUsersessions().size();
 		getUsersession().delete();
 		assertEquals(size - 1, w.getUsersessions().size());
 	}

 	private static Resource createResource() throws IOException {
 		final ResourceSetImpl resourceSet = new ResourceSetImpl();
 		tempFile = File.createTempFile("league", ".xmi"); //$NON-NLS-1$//$NON-NLS-2$
 		final Resource resource = resourceSet.createResource(
 			URI.createFileURI(tempFile.getAbsolutePath()));
 		return resource;
 	}

 	private static League createLeague() {
 		final League league = BowlingFactory.eINSTANCE.createLeague();
 		final Player player = BowlingFactory.eINSTANCE.createPlayer();
 		league.getPlayers().add(player);
 		return league;
 	}

 	// TODO: API does not support merging currently
 	// @Test
 	// public void testMerge() throws ESException {
 	//
 	// final NullProgressMonitor monitor = new NullProgressMonitor();
 	// final Player player = ProjectChangeUtil.addPlayerToProject(getLocalProject());
 	// getLocalProject().commit(monitor);
 	// ESLocalProject checkedoutCopy = getLocalProject().getRemoteProject().checkout(monitor);
 	// final Player checkedoutPlayer = (Player) checkedoutCopy.getModelElements().get(0);
 	//
 	// RunESCommand.run(new Callable<Void>() {
 	// public Void call() throws Exception {
 	// player.setName("A");
 	// return null;
 	// }
 	// });
 	//
 	// RunESCommand.run(new Callable<Void>() {
 	// public Void call() throws Exception {
 	// getLocalProject().commit(monitor);
 	// return null;
 	// }
 	// });
 	//
 	// RunESCommand.run(new Callable<Void>() {
 	// public Void call() throws Exception {
 	// checkedoutPlayer.setName("B");
 	// return null;
 	// }
 	// });
 	//
 	// checkedoutCopy.commit(null, new CommitCallbackAdapter() {
 	// @Override
 	// public boolean baseVersionOutOfDate(final ESLocalProject getLocalProject(), IProgressMonitor progressMonitor) {
 	// ESPrimaryVersionSpec baseVersion = getLocalProject().getBaseVersion();
 	// try {
 	// final ESPrimaryVersionSpec version = getLocalProject().resolveVersionSpec(ESVersionSpec.FACTORY
 	// .createHEAD(baseVersion), monitor);
 	// getLocalProject().update(version, new UpdateCallbackAdapter() {
 	// @Override
 	// public boolean conflictOccurred(
 	// org.eclipse.emf.emfstore.client.ESChangeConflict changeConflict,
 	// IProgressMonitor progressMonitor) {
 	// try {
 	// return getLocalProject().merge(version, changeConflict,
 	// new TestConflictResolver(
 	// false, 1), null, new NullProgressMonitor());
 	// } catch (ESException e) {
 	// fail("Merge failed.");
 	// }
 	// return false;
 	// };
 	// }, new NullProgressMonitor());
 	// } catch (ESException e) {
 	// fail("Expected ChangeConflictException");
 	// }
 	// return true;
 	// }
 	// }, new NullProgressMonitor());
 	// assertEquals("B", checkedoutPlayer.getName());
 	// getLocalProject().update(monitor);
 	// assertEquals("B", player.getName());
 	// assertTrue(EMFStoreClientUtil.areEqual(getLocalProject(), checkedoutCopy));
 	// }
 }
	/*******************************************************************************
	* Copyright (c) 2012-2013 EclipseSource Muenchen GmbH and others.
	*
	* 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
	*
	* Contributors:
	******************************************************************************/
	package org.eclipse.emf.emfstore.client.api.test;

	import static org.junit.Assert.assertEquals;
	import static org.junit.Assert.assertFalse;
	import static org.junit.Assert.assertNotNull;
	import static org.junit.Assert.assertNotSame;
	import static org.junit.Assert.assertTrue;
	import static org.junit.Assert.fail;

	import java.io.File;
	import java.io.IOException;
	import java.util.List;
	import java.util.concurrent.Callable;

	import org.apache.commons.io.FileUtils;
	import org.eclipse.core.runtime.NullProgressMonitor;
	import org.eclipse.emf.common.util.URI;
	import org.eclipse.emf.ecore.resource.Resource;
	import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
	import org.eclipse.emf.emfstore.bowling.BowlingFactory;
	import org.eclipse.emf.emfstore.bowling.League;
	import org.eclipse.emf.emfstore.bowling.Player;
	import org.eclipse.emf.emfstore.bowling.Tournament;
	import org.eclipse.emf.emfstore.client.ESLocalProject;
	import org.eclipse.emf.emfstore.client.ESRemoteProject;
	import org.eclipse.emf.emfstore.client.ESUsersession;
	import org.eclipse.emf.emfstore.client.ESWorkspaceProvider;
	import org.eclipse.emf.emfstore.client.callbacks.ESCommitCallback;
	import org.eclipse.emf.emfstore.client.test.common.cases.ESTestWithSharedProject;
	import org.eclipse.emf.emfstore.client.test.common.dsl.Add;
	import org.eclipse.emf.emfstore.client.test.common.dsl.Create;
	import org.eclipse.emf.emfstore.client.test.common.util.CommitCallbackAdapter;
	import org.eclipse.emf.emfstore.client.test.common.util.ProjectUtil;
	import org.eclipse.emf.emfstore.client.util.RunESCommand;
	import org.eclipse.emf.emfstore.common.model.ESModelElementId;
	import org.eclipse.emf.emfstore.common.model.ESModelElementIdFactory;
	import org.eclipse.emf.emfstore.internal.client.model.Workspace;
	import org.eclipse.emf.emfstore.internal.client.model.impl.api.ESWorkspaceImpl;
	import org.eclipse.emf.emfstore.internal.common.model.util.ModelUtil;
	import org.eclipse.emf.emfstore.server.exceptions.ESException;
	import org.eclipse.emf.emfstore.server.exceptions.ESUpdateRequiredException;
	import org.eclipse.emf.emfstore.server.model.ESBranchInfo;
	import org.eclipse.emf.emfstore.server.model.ESHistoryInfo;
	import org.eclipse.emf.emfstore.server.model.query.ESHistoryQuery;
	import org.eclipse.emf.emfstore.server.model.query.ESRangeQuery;
	import org.eclipse.emf.emfstore.server.model.versionspec.ESBranchVersionSpec;
	import org.eclipse.emf.emfstore.server.model.versionspec.ESPrimaryVersionSpec;
	import org.eclipse.emf.emfstore.server.model.versionspec.ESVersionSpec;
	import org.junit.After;
	import org.junit.AfterClass;
	import org.junit.BeforeClass;
	import org.junit.Ignore;
	import org.junit.Test;

	public class SharedProjectTest extends ESTestWithSharedProject {

	private static final String SECOND_TEST_PROJECT_NAME = "SecondTestProject"; //$NON-NLS-1$
	private static final String CHECKOUT_NAME = "testCheckout"; //$NON-NLS-1$
	private static final String NEW_BRANCH_NAME = "newBranch"; //$NON-NLS-1$
	private static final String COMMIT_MESSAGE = "SomeCommitMessage"; //$NON-NLS-1$
	private static File tempFile;

	private ESCommitCallback callback;
	private boolean noLocalChangesOccurred;

	@BeforeClass
	public static void beforeClass() {
	startEMFStore();
	}

	@AfterClass
	public static void afterClass() {
	stopEMFStore();
	}

	@After
	@Override
	public void after() {
	if (tempFile != null) {
	FileUtils.deleteQuietly(tempFile);
	tempFile = null;
	}
	super.after();
	}

	@Test
	public void testShare() {
	try {
	final ESRemoteProject remoteProject = getLocalProject().getRemoteProject();
	assertNotNull(remoteProject);
	assertTrue(getLocalProject().isShared());
	} catch (final ESException e) {
	fail(e.getMessage());
	}
	}

	@Ignore
	@Test
	public void testShareAfterRemoteProjectHasBeenDeleted() {
	try {
	final ESRemoteProject remoteProject = getLocalProject().getRemoteProject();
	assertNotNull(remoteProject);
	remoteProject.delete(new NullProgressMonitor());
	final ESUsersession session = getLocalProject().getUsersession();
	session.logout();
	session.refresh();
	assertFalse(getLocalProject().isShared());
	} catch (final ESException e) {
	fail(e.getMessage());
	}
	}

	@Test
	public void testCommit() {
	try {
	final ESPrimaryVersionSpec base = getLocalProject().getBaseVersion();
	Add.toProject(getLocalProject(), Create.player());
	final ESPrimaryVersionSpec head = getLocalProject().commit(new NullProgressMonitor());
	assertNotSame(base, head);
	} catch (final ESException e) {
	fail(e.getMessage());
	}
	}

	@Test
	public void testContains() {
	final Player player = Create.player();
	Add.toProject(getLocalProject(), player);
	final ESModelElementId id = getLocalProject().getModelElementId(player);
	final ESModelElementId clonedId = ESModelElementIdFactory.fromString(id.getId());
	assertTrue(getLocalProject().contains(player));
	assertTrue(getLocalProject().contains(id));
	assertTrue(getLocalProject().contains(clonedId));
	}

	public void testCommitWithoutChange() throws ESException {
	getLocalProject().commit(null, new CommitCallbackAdapter() {
	@Override
	public void noLocalChanges(ESLocalProject projectSpace) {
	noLocalChangesOccurred = true;
	}
	}, new NullProgressMonitor());
	assertTrue(noLocalChangesOccurred);
	}

	@Test
	public void testCommitLog() {

	try {
	final ESPrimaryVersionSpec base = getLocalProject().getBaseVersion();
	Add.toProject(getLocalProject(), Create.player());
	final ESPrimaryVersionSpec head = getLocalProject().commit(COMMIT_MESSAGE, callback,
	new NullProgressMonitor());
	assertNotSame(base, head);
	} catch (final ESException e) {
	fail(e.getMessage());
	}
	}

	@Test
	public void testCommitBranch() {

	try {
	final ESPrimaryVersionSpec base = getLocalProject().getBaseVersion();
	Add.toProject(getLocalProject(), Create.player());
	final ESBranchVersionSpec branch = ESVersionSpec.FACTORY.createBRANCH(NEW_BRANCH_NAME);
	final ESPrimaryVersionSpec head = getLocalProject().commitToBranch(branch, COMMIT_MESSAGE, callback,
	new NullProgressMonitor());
	assertNotSame(base, head);
	} catch (final ESException e) {
	fail(e.getMessage());
	}
	}

	public void testCommitBranchWithoutChange() throws ESException {
	final ESBranchVersionSpec branch = ESVersionSpec.FACTORY.createBRANCH(NEW_BRANCH_NAME);
	getLocalProject().commitToBranch(branch, COMMIT_MESSAGE, new CommitCallbackAdapter() {
	@Override
	public void noLocalChanges(ESLocalProject projectSpace) {
	noLocalChangesOccurred = true;
	}
	}, new NullProgressMonitor());
	assertTrue(noLocalChangesOccurred);
	}

	@Test
	public void testBranchesOnlyTrunk() {
	try {
	final List<? extends ESBranchInfo> branches = getLocalProject().getBranches(new NullProgressMonitor());
	assertEquals(1, branches.size());
	// TODO assert branch name
	} catch (final ESException e) {
	fail(e.getMessage());
	}
	}

	@Test
	public void testBranches() {

	try {
	List<? extends ESBranchInfo> branches = getLocalProject().getBranches(new NullProgressMonitor());
	assertEquals(1, branches.size());

	Add.toProject(getLocalProject(), Create.player());

	final ESBranchVersionSpec branch = ESVersionSpec.FACTORY.createBRANCH(NEW_BRANCH_NAME);
	getLocalProject().commitToBranch(branch, COMMIT_MESSAGE, callback,
	new NullProgressMonitor());
	branches = getLocalProject().getBranches(new NullProgressMonitor());
	assertEquals(2, branches.size());
	// TODO assert branch names
	} catch (final ESException e) {
	fail(e.getMessage());
	}
	}

	@Test
	public void testHistoryInfoOnlyTrunk() {
	try {
	final ESRangeQuery<?> query = ESHistoryQuery.FACTORY.rangeQuery(getLocalProject().getBaseVersion(), 1, 1,
	true,
	true,
	true,
	true);
	final NullProgressMonitor monitor = new NullProgressMonitor();
	List<ESHistoryInfo> infos = getLocalProject().getHistoryInfos(query, monitor);
	assertEquals(1, infos.size());

	Add.toProject(getLocalProject(), Create.player());

	assertEquals(0, getLocalProject().getBaseVersion().getIdentifier());
	final ESPrimaryVersionSpec head = getLocalProject().commit(COMMIT_MESSAGE, callback,
	new NullProgressMonitor());
	assertEquals(1, getLocalProject().getBaseVersion().getIdentifier());
	infos = getLocalProject().getHistoryInfos(
	ESHistoryQuery.FACTORY.rangeQuery(head, 1, 1, true, true, true, true),
	monitor);
	assertEquals(2, infos.size());
	// TODO assert infos
	} catch (final ESException e) {
	fail(e.getMessage());
	}
	}

	@Test
	public void testHistoryInfoBranch() {
	try {
	final ESRangeQuery<?> query = ESHistoryQuery.FACTORY.rangeQuery(getLocalProject().getBaseVersion(), 1, 1,
	true,
	true,
	true,
	true);
	final NullProgressMonitor monitor = new NullProgressMonitor();

	List<ESHistoryInfo> infos = getLocalProject().getHistoryInfos(query, monitor);
	assertEquals(1, infos.size());

	Add.toProject(getLocalProject(), Create.player());
	final ESBranchVersionSpec branch = ESVersionSpec.FACTORY.createBRANCH(NEW_BRANCH_NAME);
	getLocalProject().commitToBranch(branch, COMMIT_MESSAGE, callback,
	new NullProgressMonitor());
	infos = getLocalProject().getHistoryInfos(query, monitor);
	assertEquals(2, infos.size());
	// TODO assert infos
	} catch (final ESException e) {
	fail(e.getMessage());
	}
	}

	@Test
	public void testHasUncommitedChanges() {
	assertFalse(getLocalProject().hasUncommitedChanges());
	Add.toProject(getLocalProject(), Create.player());
	assertTrue(getLocalProject().hasUncommitedChanges());
	try {
	getLocalProject().commit(COMMIT_MESSAGE, callback, new NullProgressMonitor());
	} catch (final ESException e) {
	fail(e.getMessage());
	}
	assertFalse(getLocalProject().hasUncommitedChanges());

	}

	@Test(expected = ESUpdateRequiredException.class)
	public void testMergeAndExpectBaseVersionOutOfDateException() throws ESException {
	final NullProgressMonitor monitor = new NullProgressMonitor();
	final Player player = Create.player();
	Add.toProject(getLocalProject(), player);
	getLocalProject().commit(monitor);
	final ESLocalProject checkedoutCopy = getLocalProject().getRemoteProject().checkout(CHECKOUT_NAME, monitor);
	final Player checkedoutPlayer = (Player) checkedoutCopy.getModelElements().get(0);

	RunESCommand.run(new Callable<Void>() {
	public Void call() throws Exception {
	player.setName("A"); //$NON-NLS-1$
	return null;
	}
	});

	getLocalProject().commit(monitor);

	RunESCommand.run(new Callable<Void>() {
	public Void call() throws Exception {
	checkedoutPlayer.setName("B"); //$NON-NLS-1$
	return null;
	}
	});

	checkedoutCopy.commit(monitor);
	}

	@Test
	public void testMoveElementViaReference() throws ESException {

	final League league = Create.league("Canadian bowling league"); //$NON-NLS-1$
	final Player player = Create.player("Joe"); //$NON-NLS-1$
	RunESCommand.run(new Callable<Void>() {
	public Void call() throws Exception {
	league.getPlayers().add(player);
	getLocalProject().getModelElements().add(league);
	return null;
	}
	});
	assertTrue(getLocalProject().contains(league));

	final ESLocalProject secondProject = getWorkspace().createLocalProject(SECOND_TEST_PROJECT_NAME);
	secondProject.shareProject(new NullProgressMonitor());

	// tournament does not contain players
	final Tournament tournament = Create.tournament(false);
	RunESCommand.run(new Callable<Void>() {
	public Void call() throws Exception {
	secondProject.getModelElements().add(tournament);
	tournament.getPlayers().add(player);
	return null;
	}
	});

	getLocalProject().save();
	secondProject.save();

	assertTrue(secondProject.contains(player));
	stopEMFStore();
	startEMFStore();

	for (final ESLocalProject project : ESWorkspaceProvider.INSTANCE.getWorkspace().getLocalProjects()) {
	if (project.getProjectName().equals(SECOND_TEST_PROJECT_NAME)) {
	final Tournament t = (Tournament) project.getModelElements().get(0);
	assertEquals(t.getPlayers().size(), 1);
	}
	}
	}

	@Test
	public void testShareWithModelInExistingResource() throws IOException, ESException {
	final Resource resource = createResource();
	final League league = createLeague();
	resource.getContents().add(league);
	resource.save(ModelUtil.getResourceSaveOptions());

	final ESLocalProject project = ESWorkspaceProvider.INSTANCE.getWorkspace().createLocalProject("test"); //$NON-NLS-1$
	ProjectUtil.addElement(project, league);
	project.shareProject(getUsersession(), new NullProgressMonitor());

	assertTrue(project.isShared());
	}

	@Test
	public void testDeleteESUsersession() throws ESException {
	final Workspace w = ESWorkspaceImpl.class.cast(getWorkspace()).toInternalAPI();
	final int size = w.getUsersessions().size();
	getUsersession().delete();
	assertEquals(size - 1, w.getUsersessions().size());
	}

	private static Resource createResource() throws IOException {
	final ResourceSetImpl resourceSet = new ResourceSetImpl();
	tempFile = File.createTempFile("league", ".xmi"); //$NON-NLS-1$//$NON-NLS-2$
	final Resource resource = resourceSet.createResource(
	URI.createFileURI(tempFile.getAbsolutePath()));
	return resource;
	}

	private static League createLeague() {
	final League league = BowlingFactory.eINSTANCE.createLeague();
	final Player player = BowlingFactory.eINSTANCE.createPlayer();
	league.getPlayers().add(player);
	return league;
	}

	// TODO: API does not support merging currently
	// @Test
	// public void testMerge() throws ESException {
	//
	// final NullProgressMonitor monitor = new NullProgressMonitor();
	// final Player player = ProjectChangeUtil.addPlayerToProject(getLocalProject());
	// getLocalProject().commit(monitor);
	// ESLocalProject checkedoutCopy = getLocalProject().getRemoteProject().checkout(monitor);
	// final Player checkedoutPlayer = (Player) checkedoutCopy.getModelElements().get(0);
	//
	// RunESCommand.run(new Callable<Void>() {
	// public Void call() throws Exception {
	// player.setName("A");
	// return null;
	// }
	// });
	//
	// RunESCommand.run(new Callable<Void>() {
	// public Void call() throws Exception {
	// getLocalProject().commit(monitor);
	// return null;
	// }
	// });
	//
	// RunESCommand.run(new Callable<Void>() {
	// public Void call() throws Exception {
	// checkedoutPlayer.setName("B");
	// return null;
	// }
	// });
	//
	// checkedoutCopy.commit(null, new CommitCallbackAdapter() {
	// @Override
	// public boolean baseVersionOutOfDate(final ESLocalProject getLocalProject(), IProgressMonitor progressMonitor) {
	// ESPrimaryVersionSpec baseVersion = getLocalProject().getBaseVersion();
	// try {
	// final ESPrimaryVersionSpec version = getLocalProject().resolveVersionSpec(ESVersionSpec.FACTORY
	// .createHEAD(baseVersion), monitor);
	// getLocalProject().update(version, new UpdateCallbackAdapter() {
	// @Override
	// public boolean conflictOccurred(
	// org.eclipse.emf.emfstore.client.ESChangeConflict changeConflict,
	// IProgressMonitor progressMonitor) {
	// try {
	// return getLocalProject().merge(version, changeConflict,
	// new TestConflictResolver(
	// false, 1), null, new NullProgressMonitor());
	// } catch (ESException e) {
	// fail("Merge failed.");
	// }
	// return false;
	// };
	// }, new NullProgressMonitor());
	// } catch (ESException e) {
	// fail("Expected ChangeConflictException");
	// }
	// return true;
	// }
	// }, new NullProgressMonitor());
	// assertEquals("B", checkedoutPlayer.getName());
	// getLocalProject().update(monitor);
	// assertEquals("B", player.getName());
	// assertTrue(EMFStoreClientUtil.areEqual(getLocalProject(), checkedoutCopy));
	// }
	}