/** * Tests if <code>Version.isSame()</code> returns the right * <code>boolean</code> value */ public void testIsSameJcr2() throws Exception { assertTrue("Version.isSame(Item) did not return true", version2.isSame(versionManager.getBaseVersion(versionableNode.getPath()))); }
/** * Tests if <code>Version.isSame()</code> returns the right * <code>boolean</code> value */ public void testIsSame() throws Exception { assertTrue("Version.isSame(Item) did not return true", version2.isSame(versionableNode.getBaseVersion())); }
/** * Test if restoring a node sets the jcr:baseVersion property correctly. * * @throws javax.jcr.RepositoryException */ public void testRestoreSetsBaseVersionJcr2() throws RepositoryException { versionManager.restore(version, true); Version baseV = versionManager.getBaseVersion(versionableNode.getPath()); assertTrue("Restoring a node must set node's base version in order to point to the restored version.", version.isSame(baseV)); }
/** * Test if restoring a node sets the jcr:baseVersion property correctly. * * @throws javax.jcr.RepositoryException */ public void testRestoreSetsBaseVersionJcr2_4() throws RepositoryException { versionManager.restore(new Version[] {version}, true); Version baseV = versionManager.getBaseVersion(versionableNode.getPath()); assertTrue("Restoring a node must set node's base version in order to point to the restored version.", version.isSame(baseV)); }
/** * Test if restoring a node sets the jcr:baseVersion property correctly. * * @throws javax.jcr.RepositoryException */ public void testRestoreSetsBaseVersionJcr2_2() throws RepositoryException { versionManager.restore(version, true); Version baseV = versionManager.getBaseVersion(versionableNode.getPath()); assertTrue("Restoring a node must set node's base version in order to point to the restored version.", version.isSame(baseV)); }
/** * Test if restoring a node sets the jcr:baseVersion property correctly. * * @throws javax.jcr.RepositoryException */ public void testRestoreSetsBaseVersionJcr2_3() throws RepositoryException { versionManager.restore(versionableNode.getPath(), version.getName(), true); Version baseV = versionManager.getBaseVersion(versionableNode.getPath()); assertTrue("Restoring a node must set node's base version in order to point to the restored version.", version.isSame(baseV)); }
/** * Test that the initial base version after creation of a versionable node * points to the root version. * * @throws javax.jcr.RepositoryException */ public void testInitialBaseVersionPointsToRootVersionJcr2() throws RepositoryException { VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager(); String path = versionableNode.getPath(); Version rV = versionManager.getVersionHistory(path).getRootVersion(); Version bV = versionManager.getBaseVersion(path); assertTrue("After creation of a versionable node the node's baseVersion must point to the rootVersion in the version history.", rV.isSame(bV)); }
/** * Test if restoring a node sets the jcr:baseVersion property correctly. * * @throws javax.jcr.RepositoryException */ @SuppressWarnings("deprecation") public void testRestoreSetsBaseVersion() throws RepositoryException { versionableNode.restore(version, true); Version baseV = versionableNode.getBaseVersion(); assertTrue("Restoring a node must set node's base version in order to point to the restored version.", version.isSame(baseV)); }
/** * Test VersionHistory.getVersion(String versionName) if 'versionName' is * the name of an existing version (created by Node.checkin()). * * @see VersionHistory#getVersion(String) */ public void testGetVersion() throws RepositoryException { Version v = versionManager.checkin(versionableNode.getPath()); Version v2 = vHistory.getVersion(v.getName()); assertTrue("VersionHistory.getVersion(String versionName) must return the version that is identified by the versionName specified, if versionName is the name of a version created by Node.checkin().", v.isSame(v2)); }
/** * Test that the initial base version after creation of a versionable node * points to the root version. * * @throws javax.jcr.RepositoryException */ public void testInitialBaseVersionPointsToRootVersion() throws RepositoryException { Version rV = versionableNode.getVersionHistory().getRootVersion(); Version bV = versionableNode.getBaseVersion(); assertTrue("After creation of a versionable node the node's baseVersion must point to the rootVersion in the version history.", rV.isSame(bV)); }
/** * Test if VersionHistory.getVersionByLabel(String) returns the version that * has been specified with the addVersionLabel call. * * @throws RepositoryException * @see VersionHistory#getVersionByLabel(String) */ public void testGetVersionByLabel() throws RepositoryException { vHistory.addVersionLabel(version.getName(), versionLabel, true); Version v = vHistory.getVersionByLabel(versionLabel); assertTrue("VersionHistory.getVersionByLabel(String) must retrieve the particular version that was specified in addVersionLabel call.", v.isSame(version)); }
/** * Tests if <code>Version.getName()</code> returns the right name */ public void testGetName() throws Exception { assertTrue("Version.getName() does not return the right name", versionableNode.getVersionHistory().getVersion(version.getName()).isSame(version)); }
/** * Test if Node.checkin() on a checked-in node has no effect. * * @throws RepositoryException */ @SuppressWarnings("deprecation") public void testMultipleCheckinHasNoEffect() throws RepositoryException { Version v = versionableNode.checkin(); try { Version v2 = versionableNode.checkin(); assertTrue("Calling checkin() on a node that is already checked-in must not have an effect.", v.isSame(v2)); } catch (RepositoryException e) { fail("Calling checkin() on a node that is already checked-in must not throw an exception."); } }
/** * Test if the iterator returned by {@link javax.jcr.version.VersionHistory#getAllVersions()} * contains the root version upon creation of the version history. * * @see javax.jcr.version.VersionHistory#getRootVersion() */ public void testInitiallyGetAllVersionsContainsTheRootVersion() throws RepositoryException { Version rootVersion = vHistory.getRootVersion(); boolean isContained = false; for (VersionIterator it = vHistory.getAllVersions(); it.hasNext(); ) { isContained |= it.nextVersion().isSame(rootVersion); } assertTrue("root version must be part of the version history", isContained); }
@Test public void testPredecessorsAreWrapped() throws Exception { // GIVEN Session session = MgnlContext.getJCRSession(RepositoryConstants.WEBSITE); VersionManager versionMan = Components.getComponent(VersionManager.class); Node node = session.getRootNode().addNode( "page", NodeTypes.Page.NAME); session.save(); Version createdVersion_1 = versionMan.addVersion(node); Version createdVersion_2 = versionMan.addVersion(node); // WHEN Version[] versions = createdVersion_2.getPredecessors(); // THEN assertTrue(versions[0] instanceof ContentDecoratorVersionWrapper); assertTrue(versions[0].isSame(createdVersion_1)); } }
@Test public void testSuccessorsAreWrapped() throws Exception { // GIVEN Session session = MgnlContext.getJCRSession(RepositoryConstants.WEBSITE); VersionManager versionMan = Components.getComponent(VersionManager.class); Node node = session.getRootNode().addNode( "page", NodeTypes.Page.NAME); session.save(); Version createdVersion_1 = versionMan.addVersion(node); Version createdVersion_2 = versionMan.addVersion(node); // WHEN Version[] versions = createdVersion_1.getSuccessors(); // THEN assertTrue(versions[0] instanceof ContentDecoratorVersionWrapper); assertTrue(versions[0].isSame(createdVersion_2)); }
@Test public void testLinearSuccessorIsWrapped() throws Exception { // GIVEN Session session = MgnlContext.getJCRSession(RepositoryConstants.WEBSITE); VersionManager versionMan = Components.getComponent(VersionManager.class); Node node = session.getRootNode().addNode( "page", NodeTypes.Page.NAME); session.save(); Version createdVersion_1 = versionMan.addVersion(node); Version createdVersion_2 = versionMan.addVersion(node); // WHEN Version version = createdVersion_1.getLinearSuccessor(); // THEN assertTrue(version instanceof ContentDecoratorVersionWrapper); assertTrue(version.isSame(createdVersion_2)); }
@Test public void testVersionIsWrapped() throws Exception { // GIVEN Session session = MgnlContext.getJCRSession(RepositoryConstants.WEBSITE); VersionManager versionMan = Components.getComponent(VersionManager.class); Node node = session.getRootNode().addNode( "page", NodeTypes.Page.NAME); session.save(); Version createdVersion = versionMan.addVersion(node); VersionHistory versionHistory = versionMan.getVersionHistory(node); // WHEN Version version = versionHistory.getVersion(createdVersion.getName()); // THEN assertTrue(version instanceof ContentDecoratorVersionWrapper); assertTrue(version.isSame(createdVersion)); }
@Test public void testCopyVersionableNodeCreatesJcrCopiedFrom() throws Exception { Session session = getAdminSession(); Node toCopy = session.getNode(TEST_PATH + "/source/node"); toCopy.addMixin(JcrConstants.MIX_VERSIONABLE); session.save(); Version baseV = toCopy.getBaseVersion(); session.getWorkspace().copy(TEST_PATH + "/source/node", TEST_PATH + "/target/copied"); Node copy = testNode.getNode("target/copied"); VersionHistory copiedVh = copy.getVersionHistory(); assertTrue(copiedVh.hasProperty(VersionConstants.JCR_COPIED_FROM)); Property prop = copiedVh.getProperty(VersionConstants.JCR_COPIED_FROM); assertEquals(PropertyType.WEAKREFERENCE, prop.getType()); Node copiedFrom = prop.getNode(); assertTrue(baseV.isSame(copiedFrom)); }
public void testMoveLabel4() throws RepositoryException { versionableNode.checkout(); Version v = versionableNode.checkin(); vHistory.addVersionLabel(version.getName(), versionLabel, false); vHistory.addVersionLabel(v.getName(), versionLabel, true); Version v2 = vHistory.getVersionByLabel(versionLabel); assertTrue(v2.isSame(v)); } }