/** * Test if the a label added with VersionHistory.addVersionLabel(String, * String, boolean) corresponds to adding a reference property to the * jcr:versionLabels node of this history node, with the label as name of * the property, and the reference targeting the version. * * @see VersionHistory#addVersionLabel(String, String, boolean) */ public void testAddVersionCheckVersionLabelsNodeJcr2() throws RepositoryException { vHistory.addVersionLabel(version.getName(), versionLabel, false); // get jcr:versionLabels node vHistory = versionableNode.getSession().getWorkspace().getVersionManager().getVersionHistory(versionableNode.getPath()); Node versionLabelNode = vHistory.getNode(jcrVersionLabels); assertTrue("The version label that has been successfully added must be present in the node '" + jcrVersionLabels + "'.", versionLabelNode.getProperty(versionLabel).getString().equals(version.getUUID())); }
/** * @throws RepositoryException */ public void testFrozenChildNodeUUUID() throws RepositoryException { versionableNode.addNode("child"); versionableNode.getSession().save(); VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager(); String path = versionableNode.getPath(); Version v = versionManager.checkin(path); Node n = v.getFrozenNode().getNode("child"); String puuid = n.getProperty(jcrUUID).getValue().getString(); String nuuid = n.getIdentifier(); assertEquals("jcr:uuid needs to be equal to the getIdentifier() return value.", nuuid, puuid); }
/** * Tests if VersionHistory.getVersionableUUID() returns the uuid of the * corresponding versionable node. */ public void testGetVersionableUUID() throws RepositoryException { // create version versionableNode.checkout(); Version version = versionableNode.checkin(); assertEquals("Method getVersionableUUID() must return the UUID of the corresponding Node.", version.getContainingHistory().getVersionableUUID(), versionableNode.getUUID()); }
/** * 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)); }
/** * 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 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)); }
/** * @throws RepositoryException */ public void testFrozenNodeUUUID() throws RepositoryException { VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager(); String path = versionableNode.getPath(); Version v = versionManager.checkin(path); Node n = v.getFrozenNode(); String puuid = n.getProperty(jcrUUID).getValue().getString(); String nuuid = n.getIdentifier(); assertEquals("jcr:uuid needs to be equal to the getIdentifier() return value.", nuuid, puuid); }
public void testVersionReferencesV0() throws RepositoryException { Node n = testRootNode.addNode(nodeName1, testNodeType); n.addMixin(mixVersionable); superuser.save(); String p = n.getPath(); VersionManager vMgr = superuser.getWorkspace().getVersionManager(); Version v0 = vMgr.getVersionHistory(p).getRootVersion(); // check if versionable node has references to root version assertEquals("Root Version", v0.getIdentifier(), n.getProperty(Property.JCR_BASE_VERSION).getString()); assertEquals("Root Version", v0.getIdentifier(), n.getProperty(Property.JCR_PREDECESSORS).getValues()[0].getString()); checkReferences("Root Version", v0.getReferences(), p + "/jcr:baseVersion", p + "/jcr:predecessors" ); }
public void testFrozenNode() throws RepositoryException { Node n = testRootNode.addNode(nodeName1, testNodeType); n.addMixin(mixVersionable); Node child = n.addNode(nodeName2, ntUnstructured); superuser.save(); VersionManager vMgr = superuser.getWorkspace().getVersionManager(); vMgr.checkpoint(n.getPath()); Version v = vMgr.getBaseVersion(n.getPath()); Node frozenChild = v.getFrozenNode().getNode(child.getName()); assertEquals(ntFrozenNode, frozenChild.getPrimaryNodeType().getName()); }
public void testVersionReferencesV1() throws RepositoryException { Node n = testRootNode.addNode(nodeName1, testNodeType); n.addMixin(mixVersionable); superuser.save(); String p = n.getPath(); VersionManager vMgr = superuser.getWorkspace().getVersionManager(); Version v1 = vMgr.checkpoint(p); // check if versionable node has references to v1.0 assertEquals("v1.0", v1.getIdentifier(), n.getProperty(Property.JCR_BASE_VERSION).getString()); assertEquals("v1.0", v1.getIdentifier(), n.getProperty(Property.JCR_PREDECESSORS).getValues()[0].getString()); checkReferences("v1.0", v1.getReferences(), p + "/jcr:baseVersion", p + "/jcr:predecessors" ); }
/** * Checks if jcr:deref works when dereferencing into the version storage. */ public void testDerefToVersionNode() throws RepositoryException { Node referenced = testRootNode.addNode(nodeName1); referenced.addMixin(mixVersionable); testRootNode.save(); Version version = referenced.checkin(); Node referencedVersionNode = version.getNode(jcrFrozenNode); Node referencer = testRootNode.addNode(nodeName2); referencer.setProperty(propertyName1, referencedVersionNode); testRootNode.save(); String query = "/" + testRoot + "/*[@" + propertyName1 + "]/jcr:deref(@" + propertyName1 + ",'*')"; QueryManager qm = superuser.getWorkspace().getQueryManager(); Query q = qm.createQuery(query, Query.XPATH); QueryResult qr = q.execute(); NodeIterator ni = qr.getNodes(); assertEquals("Must find one result in query", 1, ni.getSize()); while (ni.hasNext()) { Node node = (Node) ni.next(); assertTrue(node.getProperty("jcr:frozenUuid").getString().equals(referenced.getUUID())); } }
public void testGetNodeByIdentifier() throws RepositoryException { Node n = testRootNode.addNode(nodeName1, testNodeType); n.addMixin(mixVersionable); superuser.save(); VersionManager vMgr = superuser.getWorkspace().getVersionManager(); String id = vMgr.getBaseVersion(n.getPath()).getIdentifier(); assertTrue("Session.getNodeByIdentifier() did not return Version object for a nt:version node.", superuser.getNodeByIdentifier(id) instanceof Version); }
public void testVersionFromQuery() throws RepositoryException, NotExecutableException { Node n = testRootNode.addNode(nodeName1, testNodeType); n.addMixin(mixVersionable); superuser.save(); VersionManager vMgr = superuser.getWorkspace().getVersionManager(); vMgr.checkpoint(n.getPath()); QueryManager qm = superuser.getWorkspace().getQueryManager(); Version v = vMgr.getBaseVersion(n.getPath()); Query q = qm.createQuery("//element(*, nt:version)[@jcr:uuid = '" + v.getIdentifier() + "']", Query.XPATH); NodeIterator nodes = q.execute().getNodes(); assertTrue(nodes.hasNext()); assertTrue(nodes.nextNode() instanceof Version); RowIterator rows = q.execute().getRows(); assertTrue(rows.hasNext()); assertTrue(rows.nextRow().getNode() instanceof Version); }
@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)); }
private static void assertVersionableProperties(final Session session, final String... names) throws RepositoryException { VersionManager vMgr = session.getWorkspace().getVersionManager(); for (final String mixin : MIXINS) { final String pathPrefix = VERSIONABLES_PATH_PREFIX + mixin + "/"; for (final String name : names) { final String path = pathPrefix + name; Node versionable = session.getNode(path); String versionHistoryUuid = versionable.getProperty(JCR_VERSIONHISTORY).getString(); assertEquals(getVersionHistoryForPath(session, path).getIdentifier(), versionHistoryUuid); final Version baseVersion = vMgr.getBaseVersion(path); assertEquals("1.2", baseVersion.getName()); final Value[] predecessors = versionable.getProperty(JCR_PREDECESSORS).getValues(); assertEquals(1, predecessors.length); assertEquals(baseVersion.getIdentifier(), predecessors[0].getString()); } } }
@Override protected void setUp() throws Exception { super.setUp(); Node n1 = testRootNode.addNode(nodeName1, NT_FILE); Node content = n1.addNode(JCR_CONTENT, NT_RESOURCE); content.setProperty(JCR_DATA, "val"); assertEquals(OnParentVersionAction.VERSION, n1.getDefinition().getOnParentVersion()); assertEquals(OnParentVersionAction.COPY, content.getDefinition().getOnParentVersion()); testRootNode.addMixin(MIX_VERSIONABLE); superuser.save(); versionManager = superuser.getWorkspace().getVersionManager(); frozen = versionManager.checkpoint(testRoot).getFrozenNode(); }
@Test public void createVersionedNode() throws Exception{ Node asset = JcrUtils.getOrCreateByPath("/bundlingtest/foo.png", "oak:Unstructured", "oak:Asset", s, false); asset.addMixin(JcrConstants.MIX_VERSIONABLE); Node content = asset.addNode("jcr:content", "oak:Unstructured"); content.addNode("metadata", "oak:Unstructured"); s.save(); VersionManager vm = s.getWorkspace().getVersionManager(); String assetPath = asset.getPath(); vm.checkin(assetPath); String versionedPath = vm.getBaseVersion(assetPath).getNode("jcr:frozenNode").getPath(); //Both normal node and versioned nodes should be bundled assertNull(getNodeDocument(concat(assetPath, "jcr:content"))); assertNull(getNodeDocument(concat(versionedPath, "jcr:content"))); }
/** * Test the restore of a versionable node using a label. * @throws RepositoryException */ public void testRestoreLabelJcr2() throws RepositoryException { // mark V1 with label test1 versionManager.getVersionHistory(versionableNode.getPath()).addVersionLabel(version.getName(), "test", true); // restore V1 via label. versionManager.restoreByLabel(versionableNode.getPath(), "test", true); String value = versionableNode.getProperty(propertyName1).getString(); assertEquals("Node.restore('test') not correctly restored", propertyValue1, value); }
/** * Test if restoring a node restores the correct property * * @throws RepositoryException */ public void testRestoreCorrectPropertyJcr2_3() throws RepositoryException { versionManager.restore(versionableNode.getPath(), version.getName(), true); String value = versionableNode.getProperty(propertyName1).getString(); assertEquals("Restoring a node must set the correct property.", propertyValue1, value); }
/** * 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)); }