| /******************************************************************************* |
| * 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)); |
| // } |
| } |