Index: jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/SessionMoveVersionExceptionTest.java
===================================================================
--- jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/SessionMoveVersionExceptionTest.java (revision 776807)
+++ jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/SessionMoveVersionExceptionTest.java (working copy)
@@ -39,9 +39,9 @@
public void testSessionMoveSourceCheckedInVersionException() throws RepositoryException {
// add a node under a versionable node
Node movingNode = versionableNode.addNode(nodeName1, nonVersionableNodeType.getName());
- versionableNode.save();
+ versionableNode.getSession().save();
// check the parent node in
- versionableNode.checkin();
+ versionableNode.getSession().getWorkspace().getVersionManager().checkin(versionableNode.getPath());
try {
// try to move the sub node this should throw an VersionException
// either instantly or upon save()
@@ -61,7 +61,7 @@
*/
public void testSessionMoveDestCheckedInVersionException() throws RepositoryException {
// make sure versionable node is checked in
- versionableNode.checkin();
+ versionableNode.getSession().getWorkspace().getVersionManager().checkin(versionableNode.getPath());
try {
// try to move the sub node this should throw an VersionException either instantly or upon save()
Index: jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/GetPredecessorsTest.java
===================================================================
--- jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/GetPredecessorsTest.java (revision 776807)
+++ jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/GetPredecessorsTest.java (working copy)
@@ -40,8 +40,10 @@
*/
public void testGetPredecessors() throws RepositoryException {
// create a new version
- versionableNode.checkout();
- Version version = versionableNode.checkin();
+ VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
+ String path = versionableNode.getPath();
+ versionManager.checkout(path);
+ Version version = versionManager.checkin(path);
assertTrue("Version should have at minimum one predecessor version.", version.getPredecessors().length > 0);
}
Index: jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/MergeNodeTest.java
===================================================================
--- jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/MergeNodeTest.java (revision 776807)
+++ jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/MergeNodeTest.java (working copy)
@@ -19,6 +19,7 @@
import org.apache.jackrabbit.test.NotExecutableException;
import javax.jcr.version.VersionException;
+import javax.jcr.version.VersionManager;
import javax.jcr.Node;
import javax.jcr.RepositoryException;
import javax.jcr.InvalidItemStateException;
@@ -52,7 +53,8 @@
nodeToMerge = testRootNodeW2.getNode(nodeName1);
// node has to be checked out while merging
- nodeToMerge.checkout();
+ VersionManager versionManager = nodeToMerge.getSession().getWorkspace().getVersionManager();
+ versionManager.checkout(nodeToMerge.getPath());
}
@@ -77,6 +79,22 @@
}
/**
+ * VersionManager.merge(): InvalidItemStateException if unsaved changes within the
+ * current Session
+ */
+ public void testMergeNodeWithUnsavedStatesJcr2() throws RepositoryException {
+ // set a property and do not save workspace
+ nodeToMerge.setProperty(propertyName1, CHANGED_STRING);
+ try {
+ nodeToMerge.getSession().getWorkspace().getVersionManager().merge(
+ nodeToMerge.getPath(), workspace.getName(), false);
+ fail("InvalidItemStateException if unsaved changes within the current Session was expected.");
+ } catch (InvalidItemStateException e) {
+ // success
+ }
+ }
+
+ /**
* Perform a merge on a node with a unkwnown workspacename
*/
public void testMergeUnknownWorkspaceName() throws RepositoryException {
@@ -88,6 +106,18 @@
}
/**
+ * Perform a merge on a node with a unkwnown workspacename
+ */
+ public void testMergeUnknownWorkspaceNameJcr2() throws RepositoryException {
+ try {
+ nodeToMerge.getSession().getWorkspace().getVersionManager().merge(
+ nodeToMerge.getPath(), getNonExistingWorkspaceName(superuser), false);
+ } catch (NoSuchWorkspaceException e) {
+ // success expected exception
+ }
+ }
+
+ /**
* Node.merge(): If this node does not have a corresponding node in the
* indicated workspace
then the merge method returns quietly and no
* changes are made.
@@ -104,6 +134,24 @@
}
/**
+ * VersionManager.merge(): If this node does not have a corresponding node in the
+ * indicated workspace
then the merge method returns quietly and no
+ * changes are made.
+ */
+ public void testMergeNodeNonCorrespondingNodeJcr2() throws RepositoryException {
+ // create new node - this node has no corresponding node in default workspace
+ Node subNode = nodeToMerge.addNode(nodeName3, versionableNodeType);
+ subNode.setProperty(propertyName1, CHANGED_STRING);
+ superuserW2.save();
+ VersionManager versionManager = subNode.getSession().getWorkspace().getVersionManager();
+ String path = subNode.getPath();
+ versionManager.checkin(path);
+
+ versionManager.merge(path, workspace.getName(), true);
+ assertTrue(subNode.getProperty(propertyName1).getString().equals(CHANGED_STRING));
+ }
+
+ /**
* Node.merge(): versionable subNode N checked-in: If V is neither a
* successor of, predecessor of, nor identical with V', then the merge
* result for N is failed
@@ -132,6 +180,38 @@
}
/**
+ * VersionManager.merge(): versionable subNode N checked-in: If V is neither a
+ * successor of, predecessor of, nor identical with V', then the merge
+ * result for N is failed
+ */
+ public void testMergeNodeVersionAmbiguousJcr2() throws RepositoryException {
+ // create 2 independent versions for a node and its corresponding node
+ // so merge fails for this node
+
+ // default workspace
+ Node originalNode = testRootNode.getNode(nodeName1);
+ VersionManager vmWsp1 = originalNode.getSession().getWorkspace().getVersionManager();
+ String originalPath = originalNode.getPath();
+ vmWsp1.checkout(originalPath);
+ vmWsp1.checkin(originalPath);
+
+ // second workspace
+ VersionManager vmWsp2 = nodeToMerge.getSession().getWorkspace().getVersionManager();
+ String path = nodeToMerge.getPath();
+ vmWsp2.checkin(path);
+
+ // "merge" the clonedNode with the newNode from the default workspace
+ // besteffort set to false to stop at the first failure
+ try {
+ vmWsp2.checkout(path);
+ vmWsp2.merge(path, workspace.getName(), false);
+ fail("Node has ambigous versions. Merge must throw a MergeException");
+ } catch (MergeException e) {
+ // success if the merge exception thrown
+ }
+ }
+
+ /**
* Node.merge(): bestEffort is true > any merge-failure (represented by the
* version in the workspace) is reported in the jcrMergeFailed property
*/
@@ -172,6 +252,50 @@
}
/**
+ * VersionManager.merge(): bestEffort is true > any merge-failure (represented by the
+ * version in the workspace) is reported in the jcrMergeFailed property
+ */
+ public void testMergeNodeBestEffortTrueCheckMergeFailedPropertyJcr2() throws RepositoryException {
+ // create 2 independent versions for a node and its corresponding node
+ // so merge fails for this node
+
+ // default workspace
+ Node originalNode = testRootNode.getNode(nodeName1);
+ VersionManager vmWsp1 = originalNode.getSession().getWorkspace().getVersionManager();
+ String originalPath = originalNode.getPath();
+ vmWsp1.checkout(originalPath);
+ vmWsp1.checkin(originalPath);
+
+ // second workspace
+ VersionManager vmWsp2 = nodeToMerge.getSession().getWorkspace().getVersionManager();
+ String path = nodeToMerge.getPath();
+ vmWsp2.checkin(path);
+
+ // "merge" the clonedNode with the newNode from the default workspace
+ // besteffort set to true to report all failures
+ vmWsp2.checkout(path);
+ vmWsp2.merge(path, workspace.getName(), true);
+
+ // success merge exception was raised as expected
+ // jcrMergeFailed should contains reference to the V' as it is a different branche
+ String expectedReferenceUUID = originalNode.getBaseVersion().getUUID();
+ Property mergeFailedProperty = nodeToMerge.getProperty(jcrMergeFailed);
+ Value[] references = mergeFailedProperty.getValues();
+ boolean referenceFound = false;
+ if (references != null) {
+ for (int i = 0; i < references.length; i++) {
+ String referenceUUID = references[i].getString();
+ if (referenceUUID.equals(expectedReferenceUUID)) {
+ referenceFound = true;
+ break; // it's not necessary to loop thru all the references
+ }
+ }
+
+ assertTrue("reference to expected version that give the failure wasnt found in the mergeFailed", referenceFound);
+ }
+ }
+
+ /**
* if mergeFailedProperty is present > VersionException
*/
public void disable_testMergeNodeForceFailure() throws RepositoryException {
@@ -200,6 +324,38 @@
}
/**
+ * if mergeFailedProperty is present > VersionException
+ */
+ public void disable_testMergeNodeForceFailureJcr2() throws RepositoryException {
+ // create 2 independent versions for a node and its corresponding node
+ // so merge fails for this node
+
+ // default workspace
+ Node originalNode = testRootNode.getNode(nodeName1);
+ VersionManager vmWsp1 = originalNode.getSession().getWorkspace().getVersionManager();
+ String originalPath = originalNode.getPath();
+ vmWsp1.checkout(originalPath);
+ vmWsp1.checkin(originalPath);
+
+ // second workspace
+ VersionManager vmWsp2 = nodeToMerge.getSession().getWorkspace().getVersionManager();
+ String path = nodeToMerge.getPath();
+ vmWsp2.checkin(path);
+
+ // "merge" the clonedNode with the newNode from the default workspace
+ // besteffort set to true to report all failures
+ vmWsp2.checkout(path);
+ vmWsp2.merge(path, workspace.getName(), true);
+
+ try {
+ vmWsp2.merge(path, workspace.getName(), true);
+ fail("Merge failed for node in earlier merge operations. Because the mergeFailedProperty is present, merge must throw a VersionException");
+ } catch (VersionException e) {
+ // success version exception expected
+ }
+ }
+
+ /**
* Node.merge(): bestEffort is false and any merge fails a MergeException is
* thrown.
*/
@@ -223,6 +379,32 @@
}
/**
+ * VersionManager.merge(): bestEffort is false and any merge fails a MergeException is
+ * thrown.
+ */
+ public void testMergeNodeBestEffortFalseJcr2() throws RepositoryException {
+ /// create successor versions for a node
+ // so merge fails for this node
+
+ // default workspace
+ Node originalNode = testRootNode.getNode(nodeName1);
+ VersionManager vmWsp1 = originalNode.getSession().getWorkspace().getVersionManager();
+ String originalPath = originalNode.getPath();
+ vmWsp1.checkout(originalPath);
+ vmWsp1.checkin(originalPath);
+
+ // "merge" the clonedNode with the newNode from the default workspace
+ // merge, besteffort set to false
+ try {
+ nodeToMerge.getSession().getWorkspace().getVersionManager().merge(
+ nodeToMerge.getPath(), workspace.getName(), false);
+ fail("bestEffort is false and any merge should throw a MergeException.");
+ } catch (MergeException e) {
+ // successful
+ }
+ }
+
+ /**
* A MergeVersionException is thrown if bestEffort is false and a
* versionable node is encountered whose corresponding node's base version
* is on a divergent branch from this node's base version.
@@ -252,6 +434,39 @@
}
/**
+ * A MergeVersionException is thrown if bestEffort is false and a
+ * versionable node is encountered whose corresponding node's base version
+ * is on a divergent branch from this node's base version.
+ */
+ public void testMergeNodeBestEffortFalseAmbiguousVersionsJcr2() throws RepositoryException {
+ /// create 2 independent base versions for a node and its corresponding node
+ // so merge fails for this node
+
+ // default workspace
+ Node originalNode = testRootNode.getNode(nodeName1);
+ VersionManager vmWsp1 = originalNode.getSession().getWorkspace().getVersionManager();
+ String originalPath = originalNode.getPath();
+ vmWsp1.checkout(originalPath);
+ vmWsp1.checkin(originalPath);
+
+ // second workspace
+ VersionManager vmWsp2 = nodeToMerge.getSession().getWorkspace().getVersionManager();
+ String path = nodeToMerge.getPath();
+ vmWsp2.checkin(path);
+
+ // "merge" the clonedNode with the newNode from the default workspace
+ vmWsp2.checkout(path);
+
+ // merge, besteffort set to false
+ try {
+ vmWsp2.merge(path, workspace.getName(), false);
+ fail("BestEffort is false and corresponding node's version is ambiguous. Merge should throw a MergeException.");
+ } catch (MergeException e) {
+ // successful
+ }
+ }
+
+ /**
* Tests if a {@link LockException} is thrown when merge is called on a
* locked node.
* @throws NotExecutableException if repository does not support locking.
@@ -259,8 +474,6 @@
public void disable_testMergeLocked()
throws NotExecutableException, RepositoryException {
- Session session = testRootNode.getSession();
-
if (!isSupported(Repository.OPTION_LOCKING_SUPPORTED)) {
throw new NotExecutableException("Locking is not supported.");
}
@@ -300,18 +513,69 @@
}
/**
+ * Tests if a {@link LockException} is thrown when merge is called on a
+ * locked node.
+ * @throws NotExecutableException if repository does not support locking.
+ */
+ public void disable_testMergeLockedJcr2()
+ throws NotExecutableException, RepositoryException {
+
+ if (!isSupported(Repository.OPTION_LOCKING_SUPPORTED)) {
+ throw new NotExecutableException("Locking is not supported.");
+ }
+
+ // try to make nodeToMerge lockable if it is not
+ if (!nodeToMerge.isNodeType(mixLockable)) {
+ if (nodeToMerge.canAddMixin(mixLockable)) {
+ nodeToMerge.addMixin(mixLockable);
+ } else {
+ throw new NotExecutableException("Node " + nodeToMerge.getName() + " is not lockable and " +
+ "does not allow to add mix:lockable");
+ }
+ }
+ nodeToMerge.getParent().getSession().save();
+
+ // lock the node
+ // remove first slash of path to get rel path to root
+ String pathRelToRoot = nodeToMerge.getPath().substring(1);
+ // access node through another session to lock it
+ Session session2 = helper.getSuperuserSession();
+ try {
+ Node node2 = session2.getRootNode().getNode(pathRelToRoot);
+ node2.getSession().getWorkspace().getLockManager().lock(node2.getPath(), false, false, 60, "");
+
+ try {
+ nodeToMerge.getSession().getWorkspace().getVersionManager().merge(
+ nodeToMerge.getPath(), workspace.getName(), false);
+ fail("merge must throw a LockException if applied on a " +
+ "locked node");
+ } catch (LockException e) {
+ // success
+ }
+
+ node2.getSession().getWorkspace().getLockManager().unlock(node2.getPath());
+ } finally {
+ session2.logout();
+ }
+ }
+
+ /**
* initialize a versionable node on default and second workspace
*/
protected void initNodes() throws RepositoryException {
+
+ VersionManager versionManager = testRootNode.getSession().getWorkspace().getVersionManager();
+
// create a versionable node
// nodeName1
Node topVNode = testRootNode.addNode(nodeName1, versionableNodeType);
topVNode.setProperty(propertyName1, topVNode.getName());
+ String path = topVNode.getPath();
// save default workspace
- testRootNode.save();
- topVNode.checkin();
- topVNode.checkout();
+ testRootNode.getSession().save();
+ versionManager.checkin(path);
+ versionManager.checkout(path);
log.println("test nodes created successfully on " + workspace.getName());
Index: jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionGraphTest.java
===================================================================
--- jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionGraphTest.java (revision 776807)
+++ jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionGraphTest.java (working copy)
@@ -17,6 +17,7 @@
package org.apache.jackrabbit.test.api.version;
import javax.jcr.version.Version;
+import javax.jcr.version.VersionManager;
import javax.jcr.RepositoryException;
import javax.jcr.Property;
import javax.jcr.Value;
@@ -48,6 +49,22 @@
}
/**
+ * 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 after creation of a versionable node N the multi-value
* REFERENCE property jcr:predecessors of N is initialized to contain a
* single UUID, that of the root version (the same as jcr:baseVersion).
@@ -69,6 +86,27 @@
}
/**
+ * Test if after creation of a versionable node N the multi-value
+ * REFERENCE property jcr:predecessors of N is initialized to contain a
+ * single UUID, that of the root version (the same as jcr:baseVersion).
+ *
+ * @throws RepositoryException
+ */
+ public void testInitialNodePredecessorsJcr2() throws RepositoryException {
+
+ Property predecessors = versionableNode.getProperty(jcrPredecessors);
+ Value[] values = predecessors.getValues();
+ Version rV = versionableNode.getSession().getWorkspace().getVersionManager().getVersionHistory(versionableNode.getPath()).getRootVersion();
+ if (values.length != 1) {
+ fail("The jcr:predecessors property of a versionable node must be initialized to contain a single value");
+ }
+
+ Value initialVal = values[0];
+
+ assertTrue("The jcr:predecessors property of a versionable node is initialized to contain a single UUID, that of the root version", initialVal.equals(superuser.getValueFactory().createValue(rV)));
+ }
+
+ /**
* Test if the root version does not have any predecessor versions.
*
* @throws RepositoryException
@@ -79,6 +117,16 @@
}
/**
+ * Test if the root version does not have any predecessor versions.
+ *
+ * @throws RepositoryException
+ */
+ public void testRootVersionHasNoPredecessorJcr2() throws RepositoryException {
+ Version[] predec = versionableNode.getSession().getWorkspace().getVersionManager().getVersionHistory(versionableNode.getPath()).getRootVersion().getPredecessors();
+ assertTrue("The root version may not have any predecessors.", predec.length == 0);
+ }
+
+ /**
* Test if UnsupportedRepositoryOperationException is thrown when calling
* Node.getVersionHistory() on a non-versionable node.
*
@@ -92,4 +140,19 @@
//success
}
}
+
+ /**
+ * Test if UnsupportedRepositoryOperationException is thrown when calling
+ * Node.getVersionHistory() on a non-versionable node.
+ *
+ * @throws RepositoryException
+ */
+ public void testGetBaseVersionOnNonVersionableNodeJcr2() throws RepositoryException {
+ try {
+ nonVersionableNode.getSession().getWorkspace().getVersionManager().getBaseVersion(nonVersionableNode.getPath());
+ fail("Node.getBaseVersion() must throw UnsupportedRepositoryOperationException if the node is not versionable.");
+ } catch (UnsupportedRepositoryOperationException e) {
+ //success
+ }
+ }
}
\ No newline at end of file
Index: jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/GetCreatedTest.java
===================================================================
--- jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/GetCreatedTest.java (revision 776807)
+++ jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/GetCreatedTest.java (working copy)
@@ -20,6 +20,7 @@
import java.util.GregorianCalendar;
import javax.jcr.RepositoryException;
import javax.jcr.version.Version;
+import javax.jcr.version.VersionManager;
/**
* GetCreatedTest provides test methods covering {@link
@@ -38,8 +39,10 @@
public void testGetCreated() throws RepositoryException {
// create version
- versionableNode.checkout();
- Version version = versionableNode.checkin();
+ VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
+ String path = versionableNode.getPath();
+ versionManager.checkout(path);
+ Version version = versionManager.checkin(path);
Calendar now = GregorianCalendar.getInstance();
now.add(Calendar.SECOND, 1);
@@ -47,7 +50,6 @@
assertTrue("Method getCreated() should return a creation date before current date.", version.getCreated().before(now));
}
-
/**
* Returns the date this version was created. This corresponds to the value
* of the jcr:created property in the nt:version node that represents this
@@ -56,8 +58,10 @@
public void testGetCreatedCheckAgainstProperty() throws RepositoryException {
// create version
- versionableNode.checkout();
- Version version = versionableNode.checkin();
+ VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
+ String path = versionableNode.getPath();
+ versionManager.checkout(path);
+ Version version = versionManager.checkin(path);
Calendar calGetCreated = version.getCreated();
Calendar calCreatedProp = version.getProperty(jcrCreated).getValue().getDate();
Index: jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/OnParentVersionInitializeTest.java
===================================================================
--- jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/OnParentVersionInitializeTest.java (revision 776807)
+++ jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/OnParentVersionInitializeTest.java (working copy)
@@ -20,6 +20,7 @@
import javax.jcr.Node;
import javax.jcr.version.OnParentVersionAction;
import javax.jcr.version.Version;
+import javax.jcr.version.VersionManager;
/**
* OnParentVersionInitializeTest tests the {@link OnParentVersionAction#INITIALIZE INITIALIZE}
@@ -56,4 +57,26 @@
assertEquals("On restore of a OnParentVersion-INITIALIZE property P, the current value of P must be left unchanged.", p.getString(), newPropValue);
}
+
+ /**
+ * Test the restore of a OnParentVersion-INITIALIZE property
+ *
+ * @throws javax.jcr.RepositoryException
+ */
+ public void testRestorePropJcr2() throws RepositoryException {
+
+ Node propParent = p.getParent();
+ VersionManager versionManager = propParent.getSession().getWorkspace().getVersionManager();
+ String path = propParent.getPath();
+ versionManager.checkout(path);
+ Version v = versionManager.checkin(path);
+ versionManager.checkout(path);
+
+ p.setValue(newPropValue);
+ p.getSession().save();
+
+ versionManager.restore(v, false);
+
+ assertEquals("On restore of a OnParentVersion-INITIALIZE property P, the current value of P must be left unchanged.", p.getString(), newPropValue);
+ }
}
\ No newline at end of file
Index: jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/MergeCheckedoutSubNodeTest.java
===================================================================
--- jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/MergeCheckedoutSubNodeTest.java (revision 776807)
+++ jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/MergeCheckedoutSubNodeTest.java (working copy)
@@ -19,6 +19,7 @@
import javax.jcr.MergeException;
import javax.jcr.Node;
import javax.jcr.RepositoryException;
+import javax.jcr.version.VersionManager;
/**
* MergeCheckedoutSubNodeTest contains tests dealing with
@@ -41,7 +42,8 @@
nodeToMerge = testRootNodeW2.getNode(nodeName1);
// node has to be checked out while merging
- nodeToMerge.checkout();
+ VersionManager versionManager = nodeToMerge.getSession().getWorkspace().getVersionManager();
+ versionManager.checkout(nodeToMerge.getPath());
}
protected void tearDown() throws Exception {
@@ -74,6 +76,31 @@
}
/**
+ * VersionManager.merge(): If V' of a versionable subnode N' in the source workspace
+ * is a successor of V (the base version of a subnode N in this workspace),
+ * calling merge must fail.
+ */
+ public void testFailIfCorrespondingNodeIsSuccessorJcr2() throws RepositoryException {
+ // make V' of a subnode N' in source workspace be a successor version of
+ // the base version of the corresponding subnode.
+ Node n = testRootNode.getNode(nodeName1 + "/" + nodeName2);
+ VersionManager versionManager = n.getSession().getWorkspace().getVersionManager();
+ String path = n.getPath();
+ versionManager.checkout(path);
+ versionManager.checkin(path);
+ versionManager.checkout(path);
+
+ try {
+ // merge, besteffort set to false to stop at the first failure
+ nodeToMerge.getSession().getWorkspace().getVersionManager().merge(nodeToMerge.getPath(), workspace.getName(), false);
+ fail("Merging a checkedout node if the version V' of the corresponding node is a successor of this node's base version must fail.");
+
+ } catch (MergeException e) {
+ // success
+ }
+ }
+
+ /**
* Node.merge(): If V' of a versionable subnode N' in the source workspace
* is a predeccessor of V or V' identical to V (the base version of a
* subnode N in this workspace), calling merge must be leave.
@@ -97,6 +124,30 @@
}
/**
+ * VersionManager.merge(): If V' of a versionable subnode N' in the source workspace
+ * is a predeccessor of V or V' identical to V (the base version of a
+ * subnode N in this workspace), calling merge must be leave.
+ */
+ public void testLeaveIfCorrespondingNodeIsPredeccessorJcr2() throws RepositoryException {
+ // make V' of a subnode N' in source workspace be a predeccessor version of
+ // the base version of the corresponding subnode.
+ Node n = testRootNodeW2.getNode(nodeName1 + "/" + nodeName2);
+ VersionManager versionManager = n.getSession().getWorkspace().getVersionManager();
+ String path = n.getPath();
+ versionManager.checkout(path);
+ n.setProperty(propertyName1, CHANGED_STRING);
+ testRootNodeW2.getSession().save();
+ versionManager.checkin(path);
+ versionManager.checkout(path);
+
+ // merge, besteffort set to false to stop at the first failure
+ nodeToMerge.getSession().getWorkspace().getVersionManager().merge(nodeToMerge.getPath(), workspace.getName(), false);
+
+ // check if subnode has status "leave"
+ assertTrue(n.getProperty(propertyName1).getString().equals(CHANGED_STRING));
+ }
+
+ /**
* initialize a two-step-hierarchy on default and second workspace
*/
protected void initNodes() throws RepositoryException {
@@ -111,7 +162,7 @@
subNvNode.setProperty(propertyName1, subNvNode.getName());
// save default workspace
- testRootNode.save();
+ testRootNode.getSession().save();
log.println("test nodes created successfully on " + workspace.getName());
Index: jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/MergeSubNodeTest.java
===================================================================
--- jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/MergeSubNodeTest.java (revision 776807)
+++ jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/MergeSubNodeTest.java (working copy)
@@ -19,6 +19,7 @@
import javax.jcr.Node;
import javax.jcr.NodeIterator;
import javax.jcr.RepositoryException;
+import javax.jcr.version.VersionManager;
/**
* MergeSubNodeTest contains tests dealing with sub nodes in the
@@ -42,7 +43,8 @@
nodeToMerge = testRootNodeW2.getNode(nodeName1);
// node has to be checked out while merging
- nodeToMerge.checkout();
+ VersionManager versionManager = nodeToMerge.getSession().getWorkspace().getVersionManager();
+ versionManager.checkout(nodeToMerge.getPath());
}
@@ -82,6 +84,40 @@
}
/**
+ * VersionManager.merge(): versionable subNode N: If N has status leave but parent is
+ * update, then the subnode N is removed
retrieve the initialised node
+ * to perform operations we need before for this test
+ */
+ public void disable_testRemoveNodeFromSourceWorkspaceAndMergeWithUpdateJcr2() throws RepositoryException {
+ // status 'update' for parent
+ VersionManager versionManager = nodeToMerge.getSession().getWorkspace().getVersionManager();
+ String path = nodeToMerge.getPath();
+ versionManager.checkin(path);
+ versionManager.checkout(path);
+
+ // status 'leave' for subnode
+ Node originalNode = testRootNode.getNode(nodeName1);
+ Node originalSubNode = originalNode.getNode(nodeName2);
+ VersionManager originalVersionManager = originalSubNode.getSession().getWorkspace().getVersionManager();
+ String originalSubPath = originalSubNode.getPath();
+ originalVersionManager.checkout(originalSubPath);
+ originalVersionManager.checkin(originalSubPath);
+
+ // "merge" the nodeToMerge with the newNode from the default workspace
+ // besteffort set to false to stop at the first failure
+ versionManager.merge(path, workspace.getName(), false);
+
+ // if merge passed newSubNode1 should be also removed from workspace2
+ assertFalse("subNode1 not removed from " + workspaceW2.getName() + " as expected", nodeToMerge.hasNode(nodeName2));
+
+ // return version info about the clonedNode as it must also be updated
+ final String originalBaseVersionId = originalVersionManager.getBaseVersion(originalNode.getPath()).getIdentifier();
+ final String clonedBaseVersionId = versionManager.getBaseVersion(path).getIdentifier();
+
+ assertTrue("clonedNode has different version UUID than expected, it should be updated with the newNode version UUID", originalBaseVersionId.equals(clonedBaseVersionId));
+ }
+
+ /**
* Node.merge(): versionable subNode N checked-in: If V' is a successor (to
* any degree) of V, then the merge result for N is update
modify a node
* on the workspace1 and then merge the one in workspace2 with the one in
@@ -104,7 +140,35 @@
final String clonedBaseVersionUUID = nodeToMerge.getBaseVersion().getUUID();
assertTrue("clonedNode has different version UUID than expected, it should be updated with the newNode version UUID", originalBaseVersionUUID.equals(clonedBaseVersionUUID));
+ }
+ /**
+ * VersionManager.merge(): versionable subNode N checked-in: If V' is a successor (to
+ * any degree) of V, then the merge result for N is update
modify a node
+ * on the workspace1 and then merge the one in workspace2 with the one in
+ * workspace1 precondition is that the node in workspace2 is checked in
+ */
+ public void disable_testMergeNodeFromUpdatedSourceWorkspaceJcr2() throws RepositoryException {
+ Node originalNode = testRootNode.getNode(nodeName1);
+ VersionManager originalVersionManager = originalNode.getSession().getWorkspace().getVersionManager();
+ String originalPath = originalNode.getPath();
+
+ // update nodeName1 on workspace1
+ originalVersionManager.checkout(originalPath);
+ originalVersionManager.checkin(originalPath);
+
+ testRootNode.getSession().save();
+
+ // "merge" the clonedNode with the newNode from the default workspace
+ // besteffort set to false to stop at the first failure
+ VersionManager versionManager = nodeToMerge.getSession().getWorkspace().getVersionManager();
+ String path = nodeToMerge.getPath();
+ versionManager.merge(path, workspace.getName(), false);
+
+ final String originalBaseVersionId = originalVersionManager.getBaseVersion(originalPath).getIdentifier();
+ final String clonedBaseVersionId = versionManager.getBaseVersion(path).getIdentifier();
+
+ assertTrue("clonedNode has different version UUID than expected, it should be updated with the newNode version UUID", originalBaseVersionId.equals(clonedBaseVersionId));
}
/**
@@ -130,6 +194,32 @@
}
/**
+ * VersionManager.merge(): versionable subNode N checked-in: If V' is a predecessor
+ * (to any degree) of V or if V and V' are identical (i.e., are actually the
+ * same version), then the merge result for N is leave
modify a node on
+ * the workspace2 and then merge the one in workspace2 with the one in
+ * workspace1
the node in workspace2 should be updated
precondition
+ * is that the node in workspace2 is checked in
+ */
+ public void testMergeNodeFromOlderSourceWorkspaceJcr2() throws RepositoryException {
+
+ VersionManager versionManager = nodeToMerge.getSession().getWorkspace().getVersionManager();
+ String path = nodeToMerge.getPath();
+
+ // touch the version on workspace2
+ versionManager.checkin(path);
+ versionManager.checkout(path);
+
+ String baseVersionIdbeforeMerge = versionManager.getBaseVersion(path).getIdentifier();
+
+ // "merge" the clonedNode with the newNode from the default workspace
+ // besteffort set to false to stop at the first failure
+ versionManager.merge(path, workspace.getName(), false);
+
+ assertTrue("clonedNode has different UUID than expected, it should be left unchanged", baseVersionIdbeforeMerge .equals(versionManager.getBaseVersion(path).getIdentifier()));
+ }
+
+ /**
* Node.merge(): bestEffort is true > (sub)node which could not be merged
* are not affected.
*/
@@ -167,6 +257,46 @@
}
/**
+ * VersionManager.merge(): bestEffort is true > (sub)node which could not be merged
+ * are not affected.
+ */
+ public void disable_testMergeNodeBestEffortTrueJcr2() throws RepositoryException {
+ // create 2 new nodes with two independent versions
+ // so merge fails for this node
+ Node originalNode = testRootNode.getNode(nodeName1);
+ VersionManager originalVersionManager = originalNode.getSession().getWorkspace().getVersionManager();
+ String originalPath = originalNode.getPath();
+ originalVersionManager.checkout(originalPath);
+ Node subNode = originalNode.getNode(nodeName2);
+ // will be unchanged after merge
+ originalVersionManager.checkout(subNode.getPath());
+ subNode.setProperty(propertyName1, CHANGED_STRING);
+ // will be updated
+ originalNode.setProperty(propertyName1, CHANGED_STRING);
+ superuser.save();
+ originalVersionManager.checkin(subNode.getPath());
+ originalVersionManager.checkin(originalPath);
+
+ VersionManager versionManager = nodeToMerge.getSession().getWorkspace().getVersionManager();
+ Node subNodeW2 = nodeToMerge.getNode(nodeName2);
+ versionManager.checkout(subNodeW2.getPath());
+ subNodeW2.setProperty(propertyName1, CHANGED_STRING);
+ superuserW2.save();
+ versionManager.checkin(subNodeW2.getPath());
+
+ versionManager.checkout(nodeToMerge.getPath());
+
+ // merge, besteffort set to true
+ versionManager.merge(nodeToMerge.getPath(), workspace.getName(), true);
+
+ // sub node should not be touched because merging failed
+ assertTrue(subNodeW2.getProperty(propertyName1).getString().equals(""));
+
+ // test root node should be touched because update
+ assertFalse(nodeToMerge.getProperty(propertyName1).getString().equals(nodeToMerge.getName()));
+ }
+
+ /**
* Node.merge(): For each versionable node N in the subtree rooted at this
* node,
a merge test is performed comparing N with its corresponding
* node in workspace, N'.
@@ -187,6 +317,28 @@
}
/**
+ * VersionManager.merge(): For each versionable node N in the subtree rooted at this
+ * node,
a merge test is performed comparing N with its corresponding
+ * node in workspace, N'.
+ */
+ public void disable_testMergeNodeSubNodesMergeTestJcr2() throws RepositoryException {
+ //setCheckProperty(nodeToMerge);
+ VersionManager versionManager = nodeToMerge.getSession().getWorkspace().getVersionManager();
+ String path = nodeToMerge.getPath();
+ versionManager.checkout(path);
+
+ versionManager.merge(path, workspace.getName(), true);
+
+ // check subnodes if they were touched
+ for (NodeIterator ni = nodeToMerge.getNodes(); ni.hasNext();) {
+ Node n = ni.nextNode();
+ if (versionManager.getBaseVersion(n.getPath()) != null) {
+ assertTrue(n.getProperty(propertyName1).getString().equals(CHANGED_STRING));
+ }
+ }
+ }
+
+ /**
* initialize a two-step-hierarchy on default and second workspace
*/
protected void initNodes() throws RepositoryException {
@@ -201,7 +353,7 @@
subNvNode.setProperty(propertyName1, subNvNode.getName());
// save default workspace
- testRootNode.save();
+ testRootNode.getSession().save();
log.println("test nodes created successfully on " + workspace.getName());
Index: jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/MergeNodeIteratorTest.java
===================================================================
--- jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/MergeNodeIteratorTest.java (revision 776807)
+++ jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/MergeNodeIteratorTest.java (working copy)
@@ -18,6 +18,7 @@
import javax.jcr.RepositoryException;
import javax.jcr.Node;
+import javax.jcr.version.VersionManager;
import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;
@@ -86,12 +87,56 @@
}
/**
+ * Tests if VersionManager.merge() when bestEffort is true returns a NodeIterator
+ * containing all nodes that received a fail.
+ */
+ public void testNodeIteratorJcr2() throws RepositoryException {
+
+ Node nodeToMerge = testRootNodeW2.getNode(nodeName1);
+
+ Iterator failedNodes = nodeToMerge.getSession().getWorkspace().getVersionManager().merge(
+ nodeToMerge.getPath(), workspace.getName(), true);
+
+ List nodeList = new ArrayList();
+ while (failedNodes.hasNext()) {
+ nodeList.add(failedNodes.next());
+ }
+
+ assertEquals("Node.merge() does not return a NodeIterator with " +
+ "expected number of elements.",
+ expectedFailedNodes.length,
+ nodeList.size());
+
+ // re-aquire iterator, has been consumed to get size
+ failedNodes = nodeList.iterator();
+ compareReturnedWithExpected:
+ while (failedNodes.hasNext()) {
+ String path = ((Node) failedNodes.next()).getPath();
+ for (int i = 0; i < expectedFailedNodes.length; i++) {
+ if (expectedFailedNodes[i] != null) {
+ String expectedPath = expectedFailedNodes[i].getPath();
+ if (path.equals(expectedPath)) {
+ // to assure every failed node appears only once in the
+ // NodeIterator, set each found expected node to null
+ expectedFailedNodes[i] = null;
+ continue compareReturnedWithExpected;
+ }
+ }
+ }
+ fail("Node.merge() must return a NodeIterator over all " +
+ "nodes that did receive a result of fail.");
+ }
+ }
+
+ /**
* initialize some versionable nodes on default and second workspace
*/
protected void initNodes() throws RepositoryException {
// create some versionable node in default workspace (WS1)
+ VersionManager versionManager = testRootNode.getSession().getWorkspace().getVersionManager();
+
Node mergeRootNode = testRootNode.addNode(nodeName1, versionableNodeType);
Node nodeWS1_1 = mergeRootNode.addNode(nodeName1, versionableNodeType);
@@ -100,24 +145,23 @@
Node nodeWS1_2Sub1 = nodeWS1_2.addNode(nodeName1, versionableNodeType);
Node nodeWS1_3 = mergeRootNode.addNode(nodeName3, versionableNodeType);
- testRootNode.save();
+ testRootNode.getSession().save();
- nodeWS1_1.checkin(); // create version 1.0
- nodeWS1_1.checkout();
+ versionManager.checkin(nodeWS1_1.getPath()); // create version 1.0
+ versionManager.checkout(nodeWS1_1.getPath());
- nodeWS1_1Sub1.checkin(); // create version 1.0
- nodeWS1_1Sub1.checkout();
+ versionManager.checkin(nodeWS1_1Sub1.getPath()); // create version 1.0
+ versionManager.checkout(nodeWS1_1Sub1.getPath());
- nodeWS1_2.checkin(); // create version 1.0
- nodeWS1_2.checkout();
+ versionManager.checkin(nodeWS1_2.getPath()); // create version 1.0
+ versionManager.checkout(nodeWS1_2.getPath());
- nodeWS1_2Sub1.checkin(); // create version 1.0
- nodeWS1_2Sub1.checkout();
+ versionManager.checkin(nodeWS1_2Sub1.getPath()); // create version 1.0
+ versionManager.checkout(nodeWS1_2Sub1.getPath());
- nodeWS1_3.checkin(); // create version 1.0
- nodeWS1_3.checkout();
+ versionManager.checkin(nodeWS1_3.getPath()); // create version 1.0
+ versionManager.checkout(nodeWS1_3.getPath());
-
workspaceW2.clone(workspace.getName(), mergeRootNode.getPath(), mergeRootNode.getPath(), true);
// get nodes in workspace 2
@@ -127,14 +171,14 @@
// create version branches for some of the nodes
- nodeWS2_1.checkin(); // create version 1.1
- nodeWS1_1.checkin(); // create version 1.0.1
+ versionManager.checkin(nodeWS2_1.getPath()); // create version 1.1
+ versionManager.checkin(nodeWS1_1.getPath()); // create version 1.0.1
- nodeWS2_2.checkin(); // create version 1.1
- nodeWS1_2.checkin(); // create version 1.0.1
+ versionManager.checkin(nodeWS2_2.getPath()); // create version 1.1
+ versionManager.checkin(nodeWS1_2.getPath()); // create version 1.0.1
- nodeWS2_2Sub1.checkin(); // create version 1.1
- nodeWS1_2Sub1.checkin(); // create version 1.0.1
+ versionManager.checkin(nodeWS2_2Sub1.getPath()); // create version 1.1
+ versionManager.checkin(nodeWS1_2Sub1.getPath()); // create version 1.0.1
// set the nodes with version branches in expectedFailedNodes
expectedFailedNodes[0] = nodeWS1_1;
Index: jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionTest.java
===================================================================
--- jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionTest.java (revision 776807)
+++ jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionTest.java (working copy)
@@ -19,6 +19,7 @@
import javax.jcr.nodetype.NodeType;
import javax.jcr.nodetype.ConstraintViolationException;
import javax.jcr.version.Version;
+import javax.jcr.version.VersionManager;
import javax.jcr.ItemVisitor;
import javax.jcr.Node;
import javax.jcr.RepositoryException;
@@ -29,6 +30,7 @@
import javax.jcr.Value;
import javax.jcr.PropertyType;
import javax.jcr.lock.LockException;
+import javax.jcr.lock.LockManager;
import java.util.GregorianCalendar;
import java.util.Calendar;
@@ -48,6 +50,7 @@
*/
public class VersionTest extends AbstractVersionTest {
+ private VersionManager versionManager;
private Version version;
private Version version2;
@@ -73,15 +76,17 @@
protected void setUp() throws Exception {
super.setUp();
+ versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
+
// create two versions
- version = versionableNode.checkin();
- versionableNode.checkout();
- version2 = versionableNode.checkin();
+ version = versionManager.checkin(versionableNode.getPath());
+ versionManager.checkout(versionableNode.getPath());
+ version2 = versionManager.checkin(versionableNode.getPath());
}
protected void tearDown() throws Exception {
// check the node out, so that it can be removed
- versionableNode.checkout();
+ versionManager.checkout(versionableNode.getPath());
version = null;
version2 = null;
super.tearDown();
@@ -116,13 +121,13 @@
public void testAddNode() throws Exception {
try {
version.addNode(nodeName4);
- version.save();
+ version.getSession().save();
fail("Version should be read-only: Version.addNode(String) did not throw a ConstraintViolationException");
} catch (ConstraintViolationException success) {
}
try {
version.addNode(nodeName4, ntBase);
- version.save();
+ version.getSession().save();
fail("Version should be read-only: Version.addNode(String,String) did not throw a ConstraintViolationException");
} catch (ConstraintViolationException success) {
}
@@ -149,6 +154,18 @@
}
/**
+ * Tests if Version.cancelMerge(Version) throws an {@link
+ * javax.jcr.UnsupportedRepositoryOperationException}
+ */
+ public void testCancelMergeJcr2() throws Exception {
+ try {
+ versionManager.cancelMerge(version.getPath(), version2);
+ fail("Version.cancelMerge(Version) did not throw an UnsupportedRepositoryOperationException");
+ } catch (UnsupportedRepositoryOperationException success) {
+ }
+ }
+
+ /**
* Tests if Version.checkin() throws an {@link
* javax.jcr.UnsupportedRepositoryOperationException}
*/
@@ -161,6 +178,18 @@
}
/**
+ * Tests if Version.checkin() throws an {@link
+ * javax.jcr.UnsupportedRepositoryOperationException}
+ */
+ public void testCheckinJcr2() throws Exception {
+ try {
+ versionManager.checkin(version.getPath());
+ fail("Version.checkin() did not throw an UnsupportedRepositoryOperationException");
+ } catch (UnsupportedRepositoryOperationException success) {
+ }
+ }
+
+ /**
* Tests if Version.checkout() throws an {@link
* javax.jcr.UnsupportedRepositoryOperationException}
*/
@@ -173,6 +202,18 @@
}
/**
+ * Tests if Version.checkout() throws an {@link
+ * javax.jcr.UnsupportedRepositoryOperationException}
+ */
+ public void testCheckoutJcr2() throws Exception {
+ try {
+ versionManager.checkout(version.getPath());
+ fail("Version.checkout() did not throw an UnsupportedRepositoryOperationException");
+ } catch (UnsupportedRepositoryOperationException success) {
+ }
+ }
+
+ /**
* Tests if Version.doneMerge(Version) throws an {@link
* javax.jcr.UnsupportedRepositoryOperationException}
*/
@@ -185,6 +226,18 @@
}
/**
+ * Tests if Version.doneMerge(Version) throws an {@link
+ * javax.jcr.UnsupportedRepositoryOperationException}
+ */
+ public void testDoneMergeJcr2() throws Exception {
+ try {
+ versionManager.doneMerge(version.getPath(), version2);
+ fail("Version should not be versionable: Version.doneMerge(Version) did not throw an UnsupportedRepositoryOperationException");
+ } catch (UnsupportedRepositoryOperationException success) {
+ }
+ }
+
+ /**
* Tests if Version.getAncestor(int) returns the right
* ancestor
*/
@@ -205,6 +258,18 @@
}
/**
+ * Tests if Version.getBaseVersion() throws an {@link
+ * javax.jcr.UnsupportedRepositoryOperationException}
+ */
+ public void testGetBaseVersionJcr2() throws Exception {
+ try {
+ versionManager.getBaseVersion(version.getPath());
+ fail("Version.getBaseVersion() did not throw an UnsupportedRepositoryOperationException");
+ } catch (UnsupportedRepositoryOperationException success) {
+ }
+ }
+
+ /**
* Tests if Version.getCorrespondingNodePath(String) returns
* the right path
*/
@@ -239,6 +304,18 @@
}
/**
+ * Tests if Version.getLock() throws a {@link
+ * javax.jcr.lock.LockException}
+ */
+ public void testGetLockJcr2() throws Exception {
+ try {
+ version.getSession().getWorkspace().getLockManager().getLock(version.getPath());
+ fail("Version should not be lockable: Version.getLock() did not throw a LockException");
+ } catch (LockException success) {
+ }
+ }
+
+ /**
* Tests if Version.getMixinNodeTypes() does not return null.
*/
public void testGetMixinNodeTypes() throws Exception {
@@ -356,6 +433,18 @@
}
/**
+ * Tests if Version.getVersionHistory() throws an {@link
+ * javax.jcr.UnsupportedRepositoryOperationException}
+ */
+ public void testGetVersionHistoryJcr2() throws Exception {
+ try {
+ versionManager.getVersionHistory(version.getPath());
+ fail("Version.getVersionHistory() did not throw an UnsupportedRepositoryOperationException");
+ } catch (UnsupportedRepositoryOperationException success) {
+ }
+ }
+
+ /**
* Tests if Version.getUUID() returns the right UUID
*/
public void testGetUUID() throws Exception {
@@ -401,6 +490,13 @@
}
/**
+ * Tests if Version.holdsLock() returns false
+ */
+ public void testHoldsLockJcr2() throws Exception {
+ assertFalse("Version.holdsLock() did not return false", version.getSession().getWorkspace().getLockManager().holdsLock(version.getPath()));
+ }
+
+ /**
* Tests if Version.isCheckedOut() returns true
*/
public void testIsCheckedOut() throws Exception {
@@ -408,6 +504,13 @@
}
/**
+ * Tests if Version.isCheckedOut() returns true
+ */
+ public void testIsCheckedOutJcr2() throws Exception {
+ assertTrue("Version.isCheckedOut() did not return true", versionManager.isCheckedOut(version.getPath()));
+ }
+
+ /**
* Tests if Version.isLocked() returns false
*/
public void testIsLocked() throws Exception {
@@ -415,6 +518,13 @@
}
/**
+ * Tests if Version.isLocked() returns false
+ */
+ public void testIsLockedJcr2() throws Exception {
+ assertFalse("Version.isLocked() did not return false", version.getSession().getWorkspace().getLockManager().isLocked(version.getPath()));
+ }
+
+ /**
* Tests if Version.isModified() returns false
*/
public void testIsModified() throws Exception {
@@ -452,6 +562,14 @@
}
/**
+ * Tests if Version.isSame() returns the right
+ * boolean value
+ */
+ public void testIsSameJcr2() throws Exception {
+ assertTrue("Version.isSame(Item) did not return true", version2.isSame(versionManager.getBaseVersion(versionableNode.getPath())));
+ }
+
+ /**
* Tests if Version.lock(boolean, boolean) throws a {@link
* LockException}
*/
@@ -479,6 +597,35 @@
}
/**
+ * Tests if Version.lock(boolean, boolean) throws a {@link
+ * LockException}
+ */
+ public void testLockJcr2() throws Exception {
+ LockManager lockManager = version.getSession().getWorkspace().getLockManager();
+ String path = version.getPath();
+ try {
+ lockManager.lock(path, true, true, 60, "");
+ fail("Version should not be lockable: Version.lock(true,true) did not throw a LockException");
+ } catch (LockException success) {
+ }
+ try {
+ lockManager.lock(path, true, false, 60, "");
+ fail("Version should not be lockable: Version.lock(true,false) did not throw a LockException");
+ } catch (LockException success) {
+ }
+ try {
+ lockManager.lock(path, false, true, 60, "");
+ fail("Version should not be lockable: Version.lock(false,true) did not throw a LockException");
+ } catch (LockException success) {
+ }
+ try {
+ lockManager.lock(path, false, false, 60, "");
+ fail("Version should not be lockable: Version.lock(false,false) did not throw a LockException");
+ } catch (LockException success) {
+ }
+ }
+
+ /**
* Tests if Version.merge(String) throws an
* {@link javax.jcr.nodetype.ConstraintViolationException}
*/
@@ -496,6 +643,25 @@
}
/**
+ * Tests if Version.merge(String) throws an
+ * {@link javax.jcr.nodetype.ConstraintViolationException}
+ */
+/*
+ TODO: check why this fails
+ public void testMergeJcr2() throws Exception {
+ try {
+ versionManager.merge(version.getPath(), workspaceName, true);
+ fail("Version.merge(String, true) did not throw an ConstraintViolationException");
+ } catch (ConstraintViolationException success) {
+ }
+ try {
+ versionManager.merge(version.getPath(),workspaceName, false);
+ fail("Version.merge(String, false) did not throw an ConstraintViolationException");
+ } catch (ConstraintViolationException success) {
+ }
+ }
+*/
+ /**
* Tests if Version.orderBefore(String, String) throws an
* {@link javax.jcr.UnsupportedRepositoryOperationException}
*/
@@ -525,7 +691,7 @@
public void testRemove() throws Exception {
try {
version.remove();
- versionableNode.getVersionHistory().save();
+ versionableNode.getSession().save();
fail("Version should be read-only: Version.remove() did not throw a ConstraintViolationException");
} catch (ConstraintViolationException success) {
}
@@ -569,6 +735,26 @@
}
/**
+ * Tests if Version.restore(String, boolean) and
+ * Version.restore(Version, boolean) throw an
+ * {@link UnsupportedRepositoryOperationException} and
+ * Version.restore(Version, String, boolean) throws a
+ * {@link ConstraintViolationException}.
+ */
+ public void testRestoreJcr2() throws Exception {
+ try {
+ versionManager.restore(version.getPath(), "abc", true);
+ fail("Version.restore(String,boolean) did not throw an UnsupportedRepositoryOperationException");
+ } catch (UnsupportedRepositoryOperationException success) {
+ }
+ try {
+ versionManager.restore(version.getPath(), version2, true);
+ fail("Version.restore(Version,boolean) did not throw an UnsupportedRepositoryOperationException");
+ } catch (UnsupportedRepositoryOperationException success) {
+ }
+ }
+
+ /**
* Tests if Version.restoreByLabel(String, boolean) throws an
* {@link javax.jcr.UnsupportedRepositoryOperationException}
*/
@@ -581,6 +767,18 @@
}
/**
+ * Tests if Version.restoreByLabel(String, boolean) throws an
+ * {@link javax.jcr.UnsupportedRepositoryOperationException}
+ */
+ public void testRestoreByLabelJcr2() throws Exception {
+ try {
+ versionManager.restoreByLabel(version.getPath(), "abc", true);
+ fail("Version.restoreByLabel(String,boolean) did not throw an UnsupportedRepositoryOperationException");
+ } catch (UnsupportedRepositoryOperationException success) {
+ }
+ }
+
+ /**
* Tests if
* Version.setProperty(String, String[])Version.setProperty(String, String[], int)Version.unlock() throws a {@link
+ * javax.jcr.lock.LockException}
+ */
+ public void testUnlockJcr2() throws Exception {
+ try {
+ version.getSession().getWorkspace().getLockManager().unlock(version.getPath());
+ fail("Version should not be lockable: Version.unlock() did not throw a LockException");
+ } catch (LockException success) {
+ }
+ }
+
+ /**
* Tests if VersionHistory.update(String) throws an
* {@link javax.jcr.nodetype.ConstraintViolationException}
*/
Index: jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/OnParentVersionComputeTest.java
===================================================================
--- jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/OnParentVersionComputeTest.java (revision 776807)
+++ jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/OnParentVersionComputeTest.java (working copy)
@@ -20,6 +20,7 @@
import javax.jcr.Node;
import javax.jcr.version.OnParentVersionAction;
import javax.jcr.version.Version;
+import javax.jcr.version.VersionManager;
/**
* OnParentVersionComputeTest tests the OnParentVersion {@link OnParentVersionAction#COMPUTE COMPUTE}
@@ -56,4 +57,26 @@
assertEquals("On restore of a OnParentVersion-COMPUTE property P, the current P in the workspace will be left unchanged.", p.getString(), newPropValue);
}
+
+ /**
+ * Test the restore of a OnParentVersion-COMPUTE property
+ *
+ * @throws javax.jcr.RepositoryException
+ */
+ public void testRestorePropJcr2() throws RepositoryException {
+
+ Node propParent = p.getParent();
+ VersionManager versionManager = propParent.getSession().getWorkspace().getVersionManager();
+ String path = propParent.getPath();
+ versionManager.checkout(path);
+ Version v = versionManager.checkin(path);
+ versionManager.checkout(path);
+
+ p.setValue(newPropValue);
+ p.getSession().save();
+
+ versionManager.restore(v, false);
+
+ assertEquals("On restore of a OnParentVersion-COMPUTE property P, the current P in the workspace will be left unchanged.", p.getString(), newPropValue);
+ }
}
\ No newline at end of file
Index: jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/OnParentVersionIgnoreTest.java
===================================================================
--- jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/OnParentVersionIgnoreTest.java (revision 776807)
+++ jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/OnParentVersionIgnoreTest.java (working copy)
@@ -20,6 +20,7 @@
import javax.jcr.Node;
import javax.jcr.version.OnParentVersionAction;
import javax.jcr.version.Version;
+import javax.jcr.version.VersionManager;
/**
* OnParentVersionIgnoreTest tests the OnParentVersion {@link OnParentVersionAction#IGNORE IGNORE}
@@ -58,6 +59,28 @@
}
/**
+ * Test the restore of a OnParentVersion-IGNORE property
+ *
+ * @throws javax.jcr.RepositoryException
+ */
+ public void testRestorePropJcr2() throws RepositoryException {
+
+ Node propParent = p.getParent();
+ VersionManager versionManager = propParent.getSession().getWorkspace().getVersionManager();
+ String path = propParent.getPath();
+ versionManager.checkout(path);
+ Version v = versionManager.checkin(path);
+ versionManager.checkout(path);
+
+ p.setValue(newPropValue);
+ p.getSession().save();
+
+ versionManager.restore(v, false);
+
+ assertEquals("On restore of a OnParentVersion-IGNORE property P, the current value of P must be left unchanged.", p.getString(), newPropValue);
+ }
+
+ /**
* Test the restore of a OnParentVersion-Ignore node
*
* @throws javax.jcr.RepositoryException
@@ -79,4 +102,27 @@
}
}
+ /**
+ * Test the restore of a OnParentVersion-Ignore node
+ *
+ * @throws javax.jcr.RepositoryException
+ */
+ public void testRestoreNodeJcr2() throws RepositoryException {
+
+ VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
+ String path = versionableNode.getPath();
+ versionManager.checkout(path);
+ Version v = versionManager.checkin(path);
+ versionManager.checkout(path);
+
+ // add 'ignore' child
+ String childName = addChildNode(OPVAction).getName();
+ versionableNode.getSession().save();
+
+ versionManager.restore(v, false);
+
+ if (!versionableNode.hasNode(childName)) {
+ fail("On restore of a OnParentVersion-Ignore child node, the node needs to be untouched.");
+ }
+ }
}
\ No newline at end of file
Index: jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/WorkspaceRestoreTest.java
===================================================================
--- jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/WorkspaceRestoreTest.java (revision 776807)
+++ jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/WorkspaceRestoreTest.java (working copy)
@@ -22,6 +22,7 @@
import javax.jcr.version.Version;
import javax.jcr.version.VersionException;
import javax.jcr.version.OnParentVersionAction;
+import javax.jcr.version.VersionManager;
import javax.jcr.Session;
import javax.jcr.Node;
import javax.jcr.RepositoryException;
@@ -57,11 +58,13 @@
protected void setUp() throws Exception {
super.setUp();
- version = versionableNode.checkin();
- versionableNode.checkout();
- version2 = versionableNode.checkin();
- versionableNode.checkout();
- rootVersion = versionableNode.getVersionHistory().getRootVersion();
+ VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
+ String path = versionableNode.getPath();
+ version = versionManager.checkin(path);
+ versionManager.checkout(path);
+ version2 = versionManager.checkin(path);
+ versionManager.checkout(path);
+ rootVersion = versionManager.getVersionHistory(path).getRootVersion();
// build a second versionable node below the testroot
try {
@@ -102,11 +105,11 @@
// and check versionable nodes out.
wTestRoot = (Node) wSuperuser.getItem(testRootNode.getPath());
- wVersionableNode = wSuperuser.getNodeByUUID(versionableNode.getUUID());
- wVersionableNode.checkout();
+ wVersionableNode = wSuperuser.getNodeByIdentifier(versionableNode.getIdentifier());
+ wVersionableNode.getSession().getWorkspace().getVersionManager().checkout(wVersionableNode.getPath());
- wVersionableNode2 = wSuperuser.getNodeByUUID(versionableNode2.getUUID());
- wVersionableNode2.checkout();
+ wVersionableNode2 = wSuperuser.getNodeByIdentifier(versionableNode2.getIdentifier());
+ wVersionableNode2.getSession().getWorkspace().getVersionManager().checkout(wVersionableNode2.getPath());
} catch (RepositoryException e) {
fail("Failed to setup test environment in workspace: " + e.toString());
@@ -121,9 +124,11 @@
}
// create a version of the versionable child node
- wVersionableChildNode.checkout();
- wChildVersion = wVersionableChildNode.checkin();
- wVersionableChildNode.checkout();
+ VersionManager wVersionManager = wVersionableChildNode.getSession().getWorkspace().getVersionManager();
+ String wPath = wVersionableChildNode.getPath();
+ wVersionManager.checkout(wPath);
+ wChildVersion = wVersionManager.checkin(wPath);
+ wVersionManager.checkout(wPath);
}
@@ -174,6 +179,27 @@
}
/**
+ * Test if InvalidItemStateException is thrown if the session affected by
+ * VersionManager.restore(Version[], boolean) has pending changes.
+ */
+ public void testWorkspaceRestoreWithPendingChangesJcr2() throws RepositoryException {
+ versionableNode.getSession().getWorkspace().getVersionManager().checkout(versionableNode.getPath());
+ try {
+ // modify node without calling save()
+ versionableNode.setProperty(propertyName1, propertyValue);
+
+ // create version in second workspace
+ Version v = wVersionableNode.getSession().getWorkspace().getVersionManager().checkin(wVersionableNode.getPath());
+ // try to restore that version
+ superuser.getWorkspace().getVersionManager().restore(new Version[]{v}, false);
+
+ fail("InvalidItemStateException must be thrown on attempt to call Workspace.restore(Version[], boolean) in a session having any unsaved changes pending.");
+ } catch (InvalidItemStateException e) {
+ // success
+ }
+ }
+
+ /**
* Test if VersionException is thrown if the specified version array does
* not contain a version that has a corresponding node in this workspace.
*/
@@ -187,6 +213,19 @@
}
/**
+ * Test if VersionException is thrown if the specified version array does
+ * not contain a version that has a corresponding node in this workspace.
+ */
+ public void testWorkspaceRestoreHasCorrespondingNodeJcr2() throws RepositoryException {
+ try {
+ superuser.getWorkspace().getVersionManager().restore(new Version[]{wChildVersion}, false);
+ fail("Workspace.restore(Version[], boolean) must throw VersionException if non of the specified versions has a corresponding node in the workspace.");
+ } catch (VersionException e) {
+ // success
+ }
+ }
+
+ /**
* Test if Workspace.restore(Version[], boolean) succeeds if the following two
* preconditions are fulfilled:
* - For every version V in S that corresponds to a missing node in the workspace,
@@ -206,6 +245,25 @@
}
/**
+ * Test if VersionManager.restore(Version[], boolean) succeeds if the following two
+ * preconditions are fulfilled:
+ * - For every version V in S that corresponds to a missing node in the workspace,
+ * there must also be a parent of V in S.
+ * - S must contain at least one version that corresponds to an existing
+ * node in the workspace.
+ *
+ */
+ public void testWorkspaceRestoreWithParentJcr2() throws RepositoryException {
+
+ try {
+ Version parentV = wVersionableNode.getSession().getWorkspace().getVersionManager().checkin(wVersionableNode.getPath());
+ superuser.getWorkspace().getVersionManager().restore(new Version[]{parentV, wChildVersion}, false);
+ } catch (RepositoryException e) {
+ fail("Workspace.restore(Version[], boolean) with a version that has no corresponding node must succeed if a version of a parent with correspondance is present in the version array.");
+ }
+ }
+
+ /**
* Test if the removeExisting-flag removes an existing node in case of uuid conflict.
*/
public void testWorkspaceRestoreWithRemoveExisting() throws NotExecutableException, RepositoryException {
@@ -227,6 +285,27 @@
}
/**
+ * Test if the removeExisting-flag removes an existing node in case of uuid conflict.
+ */
+ public void testWorkspaceRestoreWithRemoveExistingJcr2() throws NotExecutableException, RepositoryException {
+ // create version for parentNode of childNode
+ superuser.getWorkspace().clone(workspaceName, wVersionableChildNode.getPath(), wVersionableChildNode.getPath(), false);
+ Version parentV = versionableNode.getSession().getWorkspace().getVersionManager().checkin(versionableNode.getPath());
+
+ // move child node in order to produce the uuid conflict
+ String newChildPath = wVersionableNode2.getPath() + "/" + wVersionableChildNode.getName();
+ wSuperuser.move(wVersionableChildNode.getPath(), newChildPath);
+ wSuperuser.save();
+
+ // restore the parent with removeExisting == true >> moved child node
+ // must be removed.
+ wSuperuser.getWorkspace().getVersionManager().restore(new Version[]{parentV}, true);
+ if (wSuperuser.itemExists(newChildPath)) {
+ fail("Workspace.restore(Version[], boolean) with the boolean flag set to true, must remove the existing node in case of Uuid conflict.");
+ }
+ }
+
+ /**
* Tests if restoring the Version of an existing node throws an
* ItemExistsException if removeExisting is set to FALSE.
*/
@@ -250,7 +329,33 @@
}
}
+ /**
+ * Tests if restoring the Version of an existing node throws an
+ * ItemExistsException if removeExisting is set to FALSE.
+ */
+ public void testWorkspaceRestoreWithUUIDConflictJcr2() throws RepositoryException, NotExecutableException {
+ try {
+ // Verify that nodes used for the test are indeed versionable
+ NodeDefinition nd = wVersionableNode.getDefinition();
+ if (nd.getOnParentVersion() != OnParentVersionAction.COPY && nd.getOnParentVersion() != OnParentVersionAction.VERSION) {
+ throw new NotExecutableException("Nodes must be versionable in order to run this test.");
+ }
+ VersionManager versionManager = wVersionableNode.getSession().getWorkspace().getVersionManager();
+ String path = wVersionableNode.getPath();
+ Version v = versionManager.checkin(path);
+ versionManager.checkout(path);
+ wSuperuser.move(wVersionableChildNode.getPath(), wVersionableNode2.getPath() + "/" + wVersionableChildNode.getName());
+ wSuperuser.save();
+ wSuperuser.getWorkspace().getVersionManager().restore(new Version[]{v}, false);
+
+ fail("Node.restore( Version, boolean ): An ItemExistsException must be thrown if the node to be restored already exsits and removeExisting was set to false.");
+ } catch (ItemExistsException e) {
+ // success
+ }
+ }
+
+
/**
* Test if workspace-restoring a node works on checked-in node.
*/
@@ -262,6 +367,18 @@
}
/**
+ * Test if workspace-restoring a node works on checked-in node.
+ */
+ public void testWorkspaceRestoreOnCheckedInNodeJcr2() throws RepositoryException {
+ VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
+ String path = versionableNode.getPath();
+ if (versionManager.isCheckedOut(path)) {
+ versionManager.checkin(path);
+ }
+ superuser.getWorkspace().getVersionManager().restore(new Version[]{version}, true);
+ }
+
+ /**
* Test if workspace-restoring a node works on checked-out node.
*/
public void testWorkspaceRestoreOnCheckedOutNode() throws RepositoryException {
@@ -271,4 +388,15 @@
superuser.getWorkspace().restore(new Version[]{version}, true);
}
+ /**
+ * Test if workspace-restoring a node works on checked-out node.
+ */
+ public void testWorkspaceRestoreOnCheckedOutNodeJcr2() throws RepositoryException {
+ VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
+ String path = versionableNode.getPath();
+ if (!versionManager.isCheckedOut(path)) {
+ versionManager.checkout(path);
+ }
+ superuser.getWorkspace().getVersionManager().restore(new Version[]{version}, true);
+ }
}
Index: jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/RemoveVersionTest.java
===================================================================
--- jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/RemoveVersionTest.java (revision 776807)
+++ jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/RemoveVersionTest.java (working copy)
@@ -23,10 +23,7 @@
import javax.jcr.Node;
import javax.jcr.ReferentialIntegrityException;
import javax.jcr.Value;
-import javax.jcr.version.Version;
-import javax.jcr.version.VersionException;
-import javax.jcr.version.VersionHistory;
-import javax.jcr.version.VersionIterator;
+import javax.jcr.version.*;
import java.util.ArrayList;
import java.util.List;
@@ -52,24 +49,26 @@
protected void setUp() throws Exception {
super.setUp();
- Version testV = versionableNode.checkin(); // create 1.0
- versionableNode.checkout();
- versionableNode.checkin(); // create 1.1
- versionableNode.checkout();
- versionableNode.checkin(); // create 1.2
+ VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
+ String path = versionableNode.getPath();
+ Version testV = versionManager.checkin(path); // create 1.0
+ versionManager.checkout(path);
+ versionManager.checkin(path); // create 1.1
+ versionManager.checkout(path);
+ versionManager.checkin(path); // create 1.2
try {
- versionableNode.getVersionHistory().removeVersion(testV.getName());
+ versionManager.getVersionHistory(path).removeVersion(testV.getName());
} catch (UnsupportedRepositoryOperationException e) {
throw new NotExecutableException("Removing version is not supported: " + e.getMessage());
}
- versionableNode.checkout();
- version = versionableNode.checkin();
+ versionManager.checkout(path);
+ version = versionManager.checkin(path);
// create a second version
- versionableNode.checkout();
- version2 = versionableNode.checkin();
+ versionManager.checkout(path);
+ version2 = versionManager.checkin(path);
- vHistory = versionableNode.getVersionHistory();
+ vHistory = versionManager.getVersionHistory(path);
// build a second versionable node below the testroot
try {
@@ -95,7 +94,9 @@
* Test removed version gets invalid
*/
public void testRemovedInvalid() throws Exception {
- versionableNode.getVersionHistory().removeVersion(version.getName());
+ VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
+ String path = versionableNode.getPath();
+ versionManager.getVersionHistory(path).removeVersion(version.getName());
// assert: version has become invalid
try {
version.getPredecessors();
@@ -166,7 +167,7 @@
* @throws NotExecutableException
*/
public void testRemoveInvalidVersion() throws RepositoryException, NotExecutableException {
- Version invalidV = versionableNode2.checkin();
+ Version invalidV = versionableNode2.getSession().getWorkspace().getVersionManager().checkin(versionableNode2.getPath());
String invalidName = invalidV.getName();
// build a version name that is not present in the current history
@@ -209,7 +210,7 @@
Value refValue = superuser.getValueFactory().createValue(version);
ensureCanSetProperty(n1, propertyName1, refValue);
n1.setProperty(propertyName1, refValue);
- testRootNode.save();
+ testRootNode.getSession().save();
try {
vHistory.removeVersion(version.getName());
@@ -226,8 +227,10 @@
* Checks if all versions but the base and root one can be removed.
*/
public void testRemoveAllBut2() throws RepositoryException {
- String baseVersion = versionableNode.getBaseVersion().getName();
- VersionHistory vh = versionableNode.getVersionHistory();
+ VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
+ String path = versionableNode.getPath();
+ String baseVersion = versionManager.getBaseVersion(path).getName();
+ VersionHistory vh = versionManager.getVersionHistory(path);
VersionIterator vi = vh.getAllVersions();
while (vi.hasNext()) {
Version currenVersion = vi.nextVersion();
@@ -243,7 +246,9 @@
*/
public void testRemoveRootVersion() throws RepositoryException {
try {
- versionableNode.getVersionHistory().getRootVersion().remove();
+ VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
+ String path = versionableNode.getPath();
+ versionManager.getVersionHistory(path).getRootVersion().remove();
fail("Removal of root version should throw an exception.");
} catch (RepositoryException e) {
// ignore
@@ -255,7 +260,9 @@
*/
public void testRemoveBaseVersion() throws RepositoryException {
try {
- versionableNode.getBaseVersion().remove();
+ VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
+ String path = versionableNode.getPath();
+ versionManager.getBaseVersion(path).remove();
fail("Removal of base version should throw an exception.");
} catch (RepositoryException e) {
// ignore
Index: jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionHistoryTest.java
===================================================================
--- jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionHistoryTest.java (revision 776807)
+++ jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionHistoryTest.java (working copy)
@@ -37,6 +37,7 @@
import javax.jcr.UnsupportedRepositoryOperationException;
import javax.jcr.Value;
import javax.jcr.lock.LockException;
+import javax.jcr.lock.LockManager;
import javax.jcr.nodetype.ConstraintViolationException;
import javax.jcr.nodetype.NoSuchNodeTypeException;
import javax.jcr.nodetype.NodeType;
@@ -59,6 +60,7 @@
protected VersionHistory vHistory;
private Version version;
+ private VersionManager versionManager;
/**
* helper class used in testAccept()
@@ -82,9 +84,10 @@
protected void setUp() throws Exception {
super.setUp();
- version = versionableNode.checkin();
+ versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
+ version = versionManager.checkin(versionableNode.getPath());
- vHistory = versionableNode.getVersionHistory();
+ vHistory = versionManager.getVersionHistory(versionableNode.getPath());
if (vHistory == null) {
@@ -206,6 +209,35 @@
}
/**
+ * Test that {@link VersionHistory#getAllVersions()} returns an iterator
+ * containing the root version and all versions that have been created by
+ * Node.checkin().
+ *
+ * @see javax.jcr.version.VersionHistory#getAllVersions()
+ */
+ public void testGetAllVersionsJcr2() throws RepositoryException {
+ int cnt = 5;
+ HashMap versions = new HashMap();
+ Version v = vHistory.getRootVersion();
+ versions.put(v.getIdentifier(), v);
+ for (int i = 0; i < cnt; i++) {
+ v = versionManager.checkin(versionableNode.getPath());
+ versions.put(v.getIdentifier(), v);
+ versionManager.checkout(versionableNode.getPath());
+ }
+
+ VersionIterator it = vHistory.getAllVersions();
+ while (it.hasNext()) {
+ v = it.nextVersion();
+ if (!versions.containsKey(v.getIdentifier())) {
+ fail("VersionHistory.getAllVersions() must only contain the root version and versions, that have been created by a Node.checkin() call.");
+ }
+ versions.remove(v.getIdentifier());
+ }
+ assertTrue("VersionHistory.getAllVersions() must contain the root version and all versions that have been created with a Node.checkin() call.", versions.isEmpty());
+ }
+
+ /**
* Test that {@link VersionHistory#getAllFrozenNodes()} returns an iterator
* containing the frozen nodes of all versions that have been created by
* {@link VersionManager#checkpoint(String)}.
@@ -255,6 +287,19 @@
}
/**
+ * Test if UnsupportedRepositoryOperationException is thrown when calling
+ * Node.getVersionHistory() on a non-versionable node.
+ */
+ public void testGetVersionHistoryOnNonVersionableNodeJcr2() throws RepositoryException {
+ try {
+ versionManager.getVersionHistory(nonVersionableNode.getPath());
+ fail("Node.getVersionHistory() must throw UnsupportedRepositoryOperationException if the node is not versionable.");
+ } catch (UnsupportedRepositoryOperationException e) {
+ //success
+ }
+ }
+
+ /**
* Test VersionHistory.getVersion(String versionName) if 'versionName' is
* the name of an existing version (created by Node.checkin()).
*
@@ -262,7 +307,7 @@
*/
public void testGetVersion() throws RepositoryException {
- Version v = versionableNode.checkin();
+ 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));
@@ -284,7 +329,7 @@
public void testAddMixin() throws Exception {
try {
vHistory.addMixin(mixVersionable);
- vHistory.save();
+ vHistory.getSession().save();
fail("VersionHistory should be read-only: VersionHistory.addMixin(String) did not throw a ConstraintViolationException");
} catch (ConstraintViolationException success) {
}
@@ -298,13 +343,13 @@
public void testAddNode() throws Exception {
try {
vHistory.addNode(nodeName4);
- vHistory.save();
+ vHistory.getSession().save();
fail("VersionHistory should be read-only: VersionHistory.addNode(String) did not throw a ConstraintViolationException");
} catch (ConstraintViolationException success) {
}
try {
vHistory.addNode(nodeName4, ntBase);
- vHistory.save();
+ vHistory.getSession().save();
fail("VersionHistory should be read-only: VersionHistory.addNode(String,String) did not throw a ConstraintViolationException");
} catch (ConstraintViolationException success) {
}
@@ -331,6 +376,18 @@
}
/**
+ * Tests if VersionHistory.cancelMerge(Version) throws an
+ * {@link javax.jcr.UnsupportedRepositoryOperationException}
+ */
+ public void testCancelMergeJcr2() throws Exception {
+ try {
+ versionManager.cancelMerge(vHistory.getPath(), version);
+ fail("VersionHistory.cancelMerge(Version) did not throw an UnsupportedRepositoryOperationException");
+ } catch (UnsupportedRepositoryOperationException success) {
+ }
+ }
+
+ /**
* Tests if VersionHistory.checkin() throws an {@link
* javax.jcr.UnsupportedRepositoryOperationException}
*/
@@ -343,6 +400,18 @@
}
/**
+ * Tests if VersionHistory.checkin() throws an {@link
+ * javax.jcr.UnsupportedRepositoryOperationException}
+ */
+ public void testCheckinJcr2() throws Exception {
+ try {
+ versionManager.checkin(vHistory.getPath());
+ fail("VersionHistory.checkin() did not throw an UnsupportedRepositoryOperationException");
+ } catch (UnsupportedRepositoryOperationException success) {
+ }
+ }
+
+ /**
* Tests if VersionHistory.checkout() throws an {@link
* javax.jcr.UnsupportedRepositoryOperationException}
*/
@@ -355,6 +424,18 @@
}
/**
+ * Tests if VersionHistory.checkout() throws an {@link
+ * javax.jcr.UnsupportedRepositoryOperationException}
+ */
+ public void testCheckoutJcr2() throws Exception {
+ try {
+ versionManager.checkout(vHistory.getPath());
+ fail("VersionHistory.checkout() did not throw an UnsupportedRepositoryOperationException");
+ } catch (UnsupportedRepositoryOperationException success) {
+ }
+ }
+
+ /**
* Tests if VersionHistory.doneMerge(Version) throws an {@link
* javax.jcr.UnsupportedRepositoryOperationException}
*/
@@ -367,6 +448,18 @@
}
/**
+ * Tests if VersionHistory.doneMerge(Version) throws an {@link
+ * javax.jcr.UnsupportedRepositoryOperationException}
+ */
+ public void testDoneMergeJcr2() throws Exception {
+ try {
+ versionManager.doneMerge(vHistory.getPath(), version);
+ fail("VersionHistory should not be versionable: VersionHistory.doneMerge(Version) did not throw an UnsupportedRepositoryOperationException");
+ } catch (UnsupportedRepositoryOperationException success) {
+ }
+ }
+
+ /**
* Tests if VersionHistory.getAncestor(int) returns the right
* ancestor
*/
@@ -387,6 +480,18 @@
}
/**
+ * Tests if VersionHistory.getBaseVersion() throws an {@link
+ * javax.jcr.UnsupportedRepositoryOperationException}
+ */
+ public void testGetBaseVersionJcr2() throws Exception {
+ try {
+ versionManager.getBaseVersion(vHistory.getPath());
+ fail("VersionHistory.getBaseVersion() did not throw an UnsupportedRepositoryOperationException");
+ } catch (UnsupportedRepositoryOperationException success) {
+ }
+ }
+
+ /**
* Tests if VersionHistory.getCorrespondingNodePath(String)
* returns the right path
*/
@@ -421,6 +526,18 @@
}
/**
+ * Tests if VersionHistory.getLock() throws an {@link
+ * javax.jcr.lock.LockException}
+ */
+ public void testGetLockJcr2() throws Exception {
+ try {
+ vHistory.getSession().getWorkspace().getLockManager().getLock(vHistory.getPath());
+ fail("VersionHistory should not be lockable: VersionHistory.getLock() did not throw a LockException");
+ } catch (LockException success) {
+ }
+ }
+
+ /**
* Tests if VersionHistory.getMixinNodeTypes() does not return
* null.
*/
@@ -556,6 +673,13 @@
}
/**
+ * Tests if VersionHistory.getIdentifier() returns the right UUID
+ */
+ public void testGetIdentifier() throws Exception {
+ assertEquals("VersionHistory.getIdentifier() did not return the right Id", versionableNode.getProperty(jcrVersionHistory).getString(), vHistory.getIdentifier());
+ }
+
+ /**
* Tests if VersionHistory.getVersionHistory() throws an {@link
* javax.jcr.UnsupportedRepositoryOperationException}
*/
@@ -568,6 +692,18 @@
}
/**
+ * Tests if VersionHistory.getVersionHistory() throws an {@link
+ * javax.jcr.UnsupportedRepositoryOperationException}
+ */
+ public void testGetVersionHistoryJcr2() throws Exception {
+ try {
+ versionManager.getVersionHistory(vHistory.getPath());
+ fail("VersionHistory.getVersionHistory() did not throw an UnsupportedRepositoryOperationException");
+ } catch (UnsupportedRepositoryOperationException success) {
+ }
+ }
+
+ /**
* Tests if VersionHistory.hasNode(String) returns the right
* boolean value
*/
@@ -608,6 +744,14 @@
}
/**
+ * Tests if VersionHistory.holdsLock() returns
+ * false
+ */
+ public void testHoldsLockJcr2() throws Exception {
+ assertFalse("VersionHistory.holdsLock() did not return false", vHistory.getSession().getWorkspace().getLockManager().holdsLock(vHistory.getPath()));
+ }
+
+ /**
* Tests if VersionHistory.isCheckedOut() returns
* true
*/
@@ -616,6 +760,14 @@
}
/**
+ * Tests if VersionHistory.isCheckedOut() returns
+ * true
+ */
+ public void testIsCheckedOutJcr2() throws Exception {
+ assertTrue("VersionHistory.isCheckedOut() did not return true", versionManager.isCheckedOut(vHistory.getPath()));
+ }
+
+ /**
* Tests if VersionHistory.isLocked() returns
* false
*/
@@ -624,6 +776,14 @@
}
/**
+ * Tests if VersionHistory.isLocked() returns
+ * false
+ */
+ public void testIsLockedJcr2() throws Exception {
+ assertFalse("VersionHistory.isLocked() did not return false", vHistory.getSession().getWorkspace().getLockManager().isLocked(vHistory.getPath()));
+ }
+
+ /**
* Tests if VersionHistory.isModified() returns
* false
*/
@@ -689,6 +849,35 @@
}
/**
+ * Tests if VersionHistory.lock(boolean, boolean) throws a
+ * {@link javax.jcr.lock.LockException}
+ */
+ public void testLockJcr2() throws Exception {
+ LockManager lockManager = vHistory.getSession().getWorkspace().getLockManager();
+ String path = vHistory.getPath();
+ try {
+ lockManager.lock(path, true, true, 60, "");
+ fail("VersionHistory should not be lockable: VersionHistory.lock(true,true) did not throw a LockException");
+ } catch (LockException success) {
+ }
+ try {
+ lockManager.lock(path, true, false, 60, "");
+ fail("VersionHistory should not be lockable: VersionHistory.lock(true,false) did not throw a LockException");
+ } catch (LockException success) {
+ }
+ try {
+ lockManager.lock(path, false, true, 60, "");
+ fail("VersionHistory should not be lockable: VersionHistory.lock(false,true) did not throw a LockException");
+ } catch (LockException success) {
+ }
+ try {
+ lockManager.lock(path, false, false, 60, "");
+ fail("VersionHistory should not be lockable: VersionHistory.lock(false,false) did not throw a UnsupportedRepositoryOperationException");
+ } catch (LockException success) {
+ }
+ }
+
+ /**
* Tests if VersionHistory.merge(String) throws an
* {@link javax.jcr.nodetype.ConstraintViolationException}
*/
@@ -706,6 +895,25 @@
}
/**
+ * Tests if VersionHistory.merge(String) throws an
+ * {@link javax.jcr.nodetype.ConstraintViolationException}
+ */
+/*
+ TODO: check why this fails
+ public void testMergeJcr2() throws Exception {
+ try {
+ versionManager.merge(vHistory.getPath(), workspaceName, true);
+ fail("VersionHistory.merge(String, true) did not throw an ConstraintViolationException");
+ } catch (ConstraintViolationException success) {
+ }
+ try {
+ versionManager.merge(vHistory.getPath(), workspaceName, false);
+ fail("VersionHistory.merge(String, false) did not throw an ConstraintViolationException");
+ } catch (ConstraintViolationException success) {
+ }
+ }
+*/
+ /**
* Tests if VersionHistory.orderBefore(String, String) throws
* an {@link javax.jcr.UnsupportedRepositoryOperationException}
*/
@@ -780,6 +988,25 @@
}
/**
+ * Tests if VersionHistory.restore(String, boolean) and
+ * VersionHistory.restore(Version, boolean) throw an {@link
+ * UnsupportedRepositoryOperationException} and VersionHistory.restore(Version,
+ * String, boolean) throws a {@link ConstraintViolationException}.
+ */
+ public void testRestoreJcr2() throws Exception {
+ try {
+ versionManager.restore(vHistory.getPath(), "abc", true);
+ fail("VersionHistory.restore(String,boolean) did not throw an UnsupportedRepositoryOperationException");
+ } catch (UnsupportedRepositoryOperationException success) {
+ }
+ try {
+ versionManager.restore(vHistory.getPath(), version, true);
+ fail("VersionHistory.restore(Version,boolean) did not throw an UnsupportedRepositoryOperationException");
+ } catch (UnsupportedRepositoryOperationException success) {
+ }
+ }
+
+ /**
* Tests if VersionHistory.restoreByLabel(String, boolean)
* throws an {@link javax.jcr.UnsupportedRepositoryOperationException}
*/
@@ -792,6 +1019,18 @@
}
/**
+ * Tests if VersionHistory.restoreByLabel(String, boolean)
+ * throws an {@link javax.jcr.UnsupportedRepositoryOperationException}
+ */
+ public void testRestoreByLabelJcr2() throws Exception {
+ try {
+ versionManager.restoreByLabel(vHistory.getPath(), "abc", true);
+ fail("VersionHistory.restoreByLabel(String,boolean) did not throw an UnsupportedRepositoryOperationException");
+ } catch (UnsupportedRepositoryOperationException success) {
+ }
+ }
+
+ /**
* Tests if VersionHistory.setProperty(String,
* String[])VersionHistory.setProperty(String,
* String[], int)VersionHistory.setProperty(String,
@@ -819,37 +1058,37 @@
try {
vHistory.setProperty(propertyName1, s);
- vHistory.save();
+ vHistory.getSession().save();
fail("VersionHistory should be read-only: VersionHistory.setProperty(String,String[]) did not throw a ConstraintViolationException");
} catch (ConstraintViolationException success) {
}
try {
vHistory.setProperty(propertyName1, s, PropertyType.STRING);
- vHistory.save();
+ vHistory.getSession().save();
fail("VersionHistory should be read-only: VersionHistory.setProperty(String,String[],int) did not throw a ConstraintViolationException");
} catch (ConstraintViolationException success) {
}
try {
vHistory.setProperty(propertyName1, vArray);
- vHistory.save();
+ vHistory.getSession().save();
fail("VersionHistory should be read-only: VersionHistory.setProperty(String,Value[]) did not throw a ConstraintViolationException");
} catch (ConstraintViolationException success) {
}
try {
vHistory.setProperty(propertyName1, vArray, PropertyType.STRING);
- vHistory.save();
+ vHistory.getSession().save();
fail("VersionHistory should be read-only: VersionHistory.setProperty(String,Value[],int]) did not throw a ConstraintViolationException");
} catch (ConstraintViolationException success) {
}
try {
vHistory.setProperty(propertyName1, true);
- vHistory.save();
+ vHistory.getSession().save();
fail("VersionHistory should be read-only: VersionHistory.setProperty(String,boolean) did not throw a ConstraintViolationException");
} catch (ConstraintViolationException success) {
}
try {
vHistory.setProperty(propertyName1, 123);
- vHistory.save();
+ vHistory.getSession().save();
fail("VersionHistory should be read-only: VersionHistory.setProperty(String,double) did not throw a ConstraintViolationException");
} catch (ConstraintViolationException success) {
}
@@ -857,39 +1096,39 @@
byte[] bytes = {73, 26, 32, -36, 40, -43, -124};
InputStream inpStream = new ByteArrayInputStream(bytes);
vHistory.setProperty(propertyName1, inpStream);
- vHistory.save();
+ vHistory.getSession().save();
fail("VersionHistory should be read-only: VersionHistory.setProperty(String,InputStream) did not throw a ConstraintViolationException");
} catch (ConstraintViolationException success) {
}
try {
vHistory.setProperty(propertyName1, "abc");
- vHistory.save();
+ vHistory.getSession().save();
fail("VersionHistory should be read-only: VersionHistory.setProperty(String,String) did not throw a ConstraintViolationException");
} catch (ConstraintViolationException success) {
}
try {
Calendar c = new GregorianCalendar(1945, 1, 6, 16, 20, 0);
vHistory.setProperty(propertyName1, c);
- vHistory.save();
+ vHistory.getSession().save();
fail("VersionHistory should be read-only: VersionHistory.setProperty(String,Calendar) did not throw a ConstraintViolationException");
} catch (ConstraintViolationException success) {
}
try {
vHistory.setProperty(propertyName1, testRootNode);
- vHistory.save();
+ vHistory.getSession().save();
fail("VersionHistory should be read-only: VersionHistory.setProperty(String,Node) did not throw a ConstraintViolationException");
} catch (ConstraintViolationException success) {
}
try {
Value v = superuser.getValueFactory().createValue("abc");
vHistory.setProperty(propertyName1, v);
- vHistory.save();
+ vHistory.getSession().save();
fail("VersionHistory should be read-only: VersionHistory.setProperty(String,Value) did not throw a ConstraintViolationException");
} catch (ConstraintViolationException success) {
}
try {
vHistory.setProperty(propertyName1, -2147483650L);
- vHistory.save();
+ vHistory.getSession().save();
fail("VersionHistory should be read-only: VersionHistory.setProperty(String,long) did not throw a ConstraintViolationException");
} catch (ConstraintViolationException success) {
}
@@ -908,6 +1147,18 @@
}
/**
+ * Tests if VersionHistory.unlock() throws a {@link
+ * javax.jcr.lock.LockException}
+ */
+ public void testUnlockJcr2() throws Exception {
+ try {
+ vHistory.getSession().getWorkspace().getLockManager().unlock(vHistory.getPath());
+ fail("VersionHistory should not be lockable: VersionHistory.unlock() did not throw a LockException");
+ } catch (LockException success) {
+ }
+ }
+
+ /**
* Tests if VersionHistory.update(String) throws an
* {@link javax.jcr.nodetype.ConstraintViolationException}
*/
Index: jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/AbstractVersionTest.java
===================================================================
--- jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/AbstractVersionTest.java (revision 776807)
+++ jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/AbstractVersionTest.java (working copy)
@@ -137,7 +137,7 @@
if (!nodetype.isNodeType(mixVersionable)) {
versionableNode.addMixin(mixVersionable);
}
- parent.save();
+ parent.getSession().save();
return versionableNode;
}
Index: jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/WorkspaceMoveVersionExceptionTest.java
===================================================================
--- jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/WorkspaceMoveVersionExceptionTest.java (revision 776807)
+++ jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/WorkspaceMoveVersionExceptionTest.java (working copy)
@@ -39,9 +39,9 @@
public void testWorkspaceMoveSourceCheckedInVersionException() throws RepositoryException {
// add a node under a versionable node
Node movingNode = versionableNode.addNode(nodeName1, nonVersionableNodeType.getName());
- versionableNode.save();
+ versionableNode.getSession().save();
// check the parent node in
- versionableNode.checkin();
+ versionableNode.getSession().getWorkspace().getVersionManager().checkin(versionableNode.getPath());
try {
// try to move the sub node this should throw an VersionException either instantly or upon save()
superuser.getWorkspace().move(movingNode.getPath(), nonVersionableNode.getPath());
@@ -59,7 +59,7 @@
*/
public void testWorkspaceMoveDestCheckedInVersionException() throws RepositoryException {
// make sure versionable node is checked in
- versionableNode.checkin();
+ versionableNode.getSession().getWorkspace().getVersionManager().checkin(versionableNode.getPath());
try {
// try to move the sub node this should throw an VersionException either instantly or upon save()
Index: jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionStorageTest.java
===================================================================
--- jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionStorageTest.java (revision 776807)
+++ jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionStorageTest.java (working copy)
@@ -48,7 +48,7 @@
*/
public void testVersionStorageProtected() throws RepositoryException {
try {
- versionableNode.getBaseVersion().setProperty(jcrCreated, GregorianCalendar.getInstance());
+ versionableNode.getSession().getWorkspace().getVersionManager().getBaseVersion(versionableNode.getPath()).setProperty(jcrCreated, GregorianCalendar.getInstance());
fail("It should not be possible to modify a subnode/version in version storage.");
} catch (ConstraintViolationException e) {
// success
Index: jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/GetContainingHistoryTest.java
===================================================================
--- jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/GetContainingHistoryTest.java (revision 776807)
+++ jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/GetContainingHistoryTest.java (working copy)
@@ -17,6 +17,7 @@
package org.apache.jackrabbit.test.api.version;
import javax.jcr.version.Version;
+import javax.jcr.version.VersionManager;
import javax.jcr.RepositoryException;
/**
@@ -36,11 +37,13 @@
*/
public void testGetContainingHistory() throws RepositoryException {
// create version
- versionableNode.checkout();
- Version version = versionableNode.checkin();
+ VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
+ String path = versionableNode.getPath();
+ versionManager.checkout(path);
+ Version version = versionManager.checkin(path);
assertTrue("Method getContainingHistory() must return the same VersionHistory " +
"as getVersionHistory() of the corresponding Node.",
- versionableNode.getVersionHistory().isSame(version.getContainingHistory()));
+ versionManager.getVersionHistory(path).isSame(version.getContainingHistory()));
}
}
\ No newline at end of file
Index: jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/MergeNonVersionableSubNodeTest.java
===================================================================
--- jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/MergeNonVersionableSubNodeTest.java (revision 776807)
+++ jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/MergeNonVersionableSubNodeTest.java (working copy)
@@ -58,6 +58,30 @@
}
/**
+ * VersionManager.merge(): nonversionable subNode N: if it has no versionable
+ * ancestor, then it is updated to reflect the state of its corresponding
+ * node.
+ */
+ public void testMergeNodeNonVersionableSubNodeNonVersionableAncestorJcr2() throws RepositoryException {
+ String nodeToMergePath = nodeName1 + "/" + nodeName2 + "/" + nodeName3;
+
+ // node to merge in second workspace
+ Node nodeToMerge = testRootNodeW2.getNode(nodeToMergePath);
+ // corresponding node to nodeToMerge in default workspace
+ Node correspondingNode = testRootNode.getNode(nodeToMergePath);
+
+ // modify value for non'v node in workspace2 so we can check if node in workspace2 after merge is updated
+ // to reflect the state of its corresponding node in default workspace....
+ nodeToMerge.setProperty(propertyName1, CHANGED_STRING);
+ nodeToMerge.getSession().save();
+ nodeToMerge.getSession().getWorkspace().getVersionManager().merge(
+ nodeToMerge.getPath(), workspace.getName(), true);
+
+ // test if modification on non-v node is done according to corresponding node.
+ assertTrue(nodeToMerge.getProperty(propertyName1).getString().equals(correspondingNode.getName()));
+ }
+
+ /**
* Node.merge(): nonversionable subNode N: if the merge result of its
* nearest versionable ancestor is update,
then it is updated to reflect
* the state of its corresponding node.
@@ -91,6 +115,39 @@
}
/**
+ * VersionManager.merge(): nonversionable subNode N: if the merge result of its
+ * nearest versionable ancestor is update,
then it is updated to reflect
+ * the state of its corresponding node.
+ */
+ public void testMergeNodeNonVersionableSubNodeUpdateJcr2() throws RepositoryException {
+ // modify non versionable subnode so we can check if it's updated after merge
+ String changedString = CHANGED_STRING + System.currentTimeMillis();
+ String nvSubNodePath = nodeName2 + "/" + nodeName3;
+
+ // versionable ancestor to merge in first workspace (N)
+ Node n = testRootNodeW2.getNode(nodeName1);
+
+ // versionable ancestor to merge in second workspace (N')
+ Node np = testRootNodeW2.getNode(nodeName1);
+
+ // checkout N and make change
+ n.getSession().getWorkspace().getVersionManager().checkout(n.getPath());
+ Node nvSubNode = n.getNode(nvSubNodePath);
+ nvSubNode.setProperty(propertyName1, changedString);
+ n.getSession().save();
+ n.getSession().getWorkspace().getVersionManager().checkin(n.getPath());
+
+ // merge change into N'
+ np.getSession().getWorkspace().getVersionManager().merge(np.getPath(), workspaceW2.getName(), true);
+
+ // corresponding node to nvSubNode in 2nd workspace
+ Node nvSubNodeP = np.getNode(nvSubNodePath);
+
+ // test if modification on N was merged into N' subnode
+ assertTrue(nvSubNodeP.getProperty(propertyName1).getString().equals(changedString));
+ }
+
+ /**
* Node.merge(): nonversionable subNode N: is left unchanged if the nearest
* versionable ancestor has state leave.
*/
@@ -123,6 +180,38 @@
}
/**
+ * VersionManager.merge(): nonversionable subNode N: is left unchanged if the nearest
+ * versionable ancestor has state leave.
+ */
+ public void testMergeNodeNonVersionableSubNodeLeaveJcr2() throws RepositoryException {
+ // modify non versionable subnode so we can check if it's updated after merge
+ String changedString = CHANGED_STRING + System.currentTimeMillis();
+ String nvSubNodePath = nodeName2 + "/" + nodeName3;
+
+ // versionable ancestor to merge in first workspace (N)
+ Node n = testRootNodeW2.getNode(nodeName1);
+
+ // versionable ancestor to merge in second workspace (N')
+ Node np = testRootNodeW2.getNode(nodeName1);
+
+ // checkout N' and make change
+ np.getSession().getWorkspace().getVersionManager().checkout(np.getPath());
+ Node nvSubNodeP = np.getNode(nvSubNodePath);
+ nvSubNodeP.setProperty(propertyName1, changedString);
+ np.getSession().save();
+ np.getSession().getWorkspace().getVersionManager().checkin(np.getPath());
+
+ // merge into N'
+ np.getSession().getWorkspace().getVersionManager().merge(np.getPath(), workspaceW2.getName(), true);
+
+ // corresponding node to nvSubNode in 2nd workspace
+ Node nvSubNode = np.getNode(nvSubNodePath);
+
+ // test if modification on N' was not modified
+ assertTrue(nvSubNode.getProperty(propertyName1).getString().equals(changedString));
+ }
+
+ /**
* initialize a three-step-hierarchy on default and second workspace
*/
protected void initNodes() throws RepositoryException {
@@ -142,7 +231,7 @@
subSubNvNode.setProperty(propertyName1, subSubNvNode.getName());
// save default workspace
- testRootNode.save();
+ testRootNode.getSession().save();
log.println("test nodes created successfully on " + workspace.getName());
Index: jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/OnParentVersionAbortTest.java
===================================================================
--- jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/OnParentVersionAbortTest.java (revision 776807)
+++ jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/OnParentVersionAbortTest.java (working copy)
@@ -21,6 +21,7 @@
import javax.jcr.RepositoryException;
import javax.jcr.version.OnParentVersionAction;
import javax.jcr.version.VersionException;
+import javax.jcr.version.VersionManager;
/**
* OnParentVersionAbortTest tests the OnParentVersion {@link OnParentVersionAction#ABORT ABORT}
@@ -54,6 +55,23 @@
}
/**
+ * Test the restore of a OnParentVersion-ABORT property
+ *
+ * @throws javax.jcr.RepositoryException
+ */
+ public void testRestorePropJcr2() throws RepositoryException {
+ try {
+ VersionManager versionManager = p.getSession().getWorkspace().getVersionManager();
+ String path = p.getParent().getPath();
+ versionManager.checkout(path);
+ versionManager.checkin(path);
+ fail("On checkin of N which has a property with OnParentVersion ABORT defined, an UnsupportedRepositoryOperationException must be thrown.");
+ } catch (VersionException e) {
+ // success
+ }
+ }
+
+ /**
* Test the restore of a OnParentVersion-ABORT node
*
* @throws RepositoryException
@@ -70,4 +88,22 @@
// success
}
}
+
+ /**
+ * Test the restore of a OnParentVersion-ABORT node
+ *
+ * @throws RepositoryException
+ * @throws NotExecutableException
+ */
+ public void testRestoreNodeJcr2() throws RepositoryException, NotExecutableException {
+ // create child node with OPV-ABORT behaviour
+ addChildNode(OPVAction);
+ testRootNode.getSession().save();
+ try {
+ versionableNode.getSession().getWorkspace().getVersionManager().checkin(versionableNode.getPath());
+ fail("On checkin of N which has a child node with OnParentVersion ABORT defined, an UnsupportedRepositoryOperationException must be thrown.");
+ } catch (VersionException e) {
+ // success
+ }
+ }
}
\ No newline at end of file
Index: jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionLabelTest.java
===================================================================
--- jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionLabelTest.java (revision 776807)
+++ jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionLabelTest.java (working copy)
@@ -24,6 +24,7 @@
import javax.jcr.version.Version;
import javax.jcr.version.VersionException;
import javax.jcr.version.VersionHistory;
+import javax.jcr.version.VersionManager;
/**
* VersionLabelTest covers methods related to version label such as
@@ -61,7 +62,7 @@
jcrVersionLabels = superuser.getNamespacePrefix(NS_JCR_URI) + ":versionLabels";
- vHistory = versionableNode.getVersionHistory();
+ vHistory = versionableNode.getSession().getWorkspace().getVersionManager().getVersionHistory(versionableNode.getPath());
rootVersion = vHistory.getRootVersion();
if (vHistory.hasVersionLabel(versionLabel)) {
@@ -141,6 +142,24 @@
}
/**
+ * 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(rootVersion.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(rootVersion.getUUID()));
+ }
+
+ /**
* Test if VersionHistory.hasVersionLabel(String) returns true, if the label
* has beed successfully added before.
*
@@ -198,6 +217,27 @@
}
/**
+ * Test if VersionHistory.addVersionLabel(versionName, label, moveLabel)
+ * throws VersionException the label already exists and if moveLabel is false)
+ *
+ * @throws RepositoryException
+ */
+ public void testAddDuplicateVersionLabelJcr2() throws RepositoryException {
+ vHistory.addVersionLabel(rootVersion.getName(), versionLabel, false);
+ try {
+ VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
+ String path = versionableNode.getPath();
+ versionManager.checkout(path);
+ Version v = versionManager.checkin(path);
+ vHistory.addVersionLabel(v.getName(), versionLabel, false);
+
+ fail("Adding a version label that already exist in the version history must throw a VersionException.");
+ } catch (VersionException e) {
+ //success
+ }
+ }
+
+ /**
* Test if the 'moveLabel' flag moves an existing version label.
*
* @throws RepositoryException
@@ -220,6 +260,30 @@
}
/**
+ * Test if the 'moveLabel' flag moves an existing version label.
+ *
+ * @throws RepositoryException
+ * @see VersionHistory#addVersionLabel(String, String, boolean) with boolan flag equals true.
+ */
+ public void testMoveLabelJcr2() throws RepositoryException {
+ vHistory.addVersionLabel(rootVersion.getName(), versionLabel, false);
+ try {
+ VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
+ String path = versionableNode.getPath();
+ versionManager.checkout(path);
+ Version v = versionManager.checkin(path);
+ vHistory.addVersionLabel(v.getName(), versionLabel, true);
+
+ if (!vHistory.hasVersionLabel(v, versionLabel)) {
+ fail("If 'moveLabel' is true, an existing version label must be moved to the indicated version.");
+ }
+
+ } catch (VersionException e) {
+ fail("If 'moveLabel' is true, an existing version label must be moved to the indicated version.");
+ }
+ }
+
+ /**
* Test the removal of an version label that does not exist (must throw VersionException).
*
* @throws RepositoryException
@@ -295,6 +359,38 @@
}
/**
+ * Test VersionHistory.getVersionLabels() returns all labels present on the version history.
+ *
+ * @throws RepositoryException
+ * @see javax.jcr.version.VersionHistory#getVersionLabels()
+ */
+ public void testGetVersionLabelsJcr2() throws RepositoryException {
+
+ HashSet testLabels = new HashSet(Arrays.asList(vHistory.getVersionLabels()));
+
+ VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
+ String path = versionableNode.getPath();
+ versionManager.checkout(path);
+ Version v = versionManager.checkin(path);
+
+ vHistory.addVersionLabel(v.getName(), versionLabel, false);
+ testLabels.add(versionLabel);
+ vHistory.addVersionLabel(rootVersion.getName(), versionLabel2, false);
+ testLabels.add(versionLabel2);
+
+ String[] labels = vHistory.getVersionLabels();
+ for (int i = 0; i < labels.length; i++) {
+ String l = labels[i];
+ if (!testLabels.contains(l)) {
+ fail("VersionHistory.getVersionLabels() must only return labels, that have been added to the history.");
+ }
+ testLabels.remove(l);
+ }
+
+ assertTrue("VersionHistory.getVersionLabels() must return all labels, that have been added to the history.", testLabels.isEmpty());
+ }
+
+ /**
* Test VersionHistory.getVersionLabels(Version) only returns all labels present
* for the specified version.
*
@@ -326,6 +422,39 @@
}
/**
+ * Test VersionHistory.getVersionLabels(Version) only returns all labels present
+ * for the specified version.
+ *
+ * @throws RepositoryException
+ * @see VersionHistory#getVersionLabels(javax.jcr.version.Version)
+ */
+ public void testGetVersionLabelsForVersionJcr2() throws RepositoryException {
+
+ HashSet testLabels = new HashSet(Arrays.asList(vHistory.getVersionLabels(rootVersion)));
+
+ vHistory.addVersionLabel(rootVersion.getName(), versionLabel, false);
+ testLabels.add(versionLabel);
+
+ // add a version label to another version (not added to the testLabel set)
+ VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
+ String path = versionableNode.getPath();
+ versionManager.checkout(path);
+ Version v = versionManager.checkin(path);
+ vHistory.addVersionLabel(v.getName(), versionLabel2, false);
+
+ String[] labels = vHistory.getVersionLabels(rootVersion);
+ for (int i = 0; i < labels.length; i++) {
+ String l = labels[i];
+ if (!testLabels.contains(l)) {
+ fail("VersionHistory.getVersionLabels(Version) must only return labels, that have been added for this version.");
+ }
+ testLabels.remove(l);
+ }
+
+ assertTrue("VersionHistory.getVersionLabels(Version) must return all labels, that have been added for this version.", testLabels.isEmpty());
+ }
+
+ /**
* Test calling Node.restoreByLabel(String, boolean) on a non-versionable node.
*
* @throws javax.jcr.RepositoryException
@@ -341,6 +470,21 @@
}
/**
+ * Test calling Node.restoreByLabel(String, boolean) on a non-versionable node.
+ *
+ * @throws javax.jcr.RepositoryException
+ * @see javax.jcr.Node#restoreByLabel(String, boolean)
+ */
+ public void testRestoreByLabelNonVersionableNodeJcr2() throws RepositoryException {
+ try {
+ nonVersionableNode.getSession().getWorkspace().getVersionManager().restoreByLabel(nonVersionableNode.getPath(), versionLabel, true);
+ fail("Node.restoreByLabel(String, boolean) on a non versionable node must throw UnsupportedRepositoryOperationException");
+ } catch (UnsupportedRepositoryOperationException e) {
+ //success
+ }
+ }
+
+ /**
* Test if versionHistory.getVersionLabels(Version) throws a VersionException if the
* specified version is not in this version history.
*/
Index: jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/MergeCancelMergeTest.java
===================================================================
--- jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/MergeCancelMergeTest.java (revision 776807)
+++ jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/MergeCancelMergeTest.java (working copy)
@@ -21,6 +21,7 @@
import javax.jcr.RepositoryException;
import javax.jcr.Value;
import javax.jcr.version.Version;
+import javax.jcr.version.VersionManager;
/**
* MergeCancelMergeTest contains tests dealing with nodes on which
@@ -43,7 +44,8 @@
nodeToMerge = testRootNodeW2.getNode(nodeName1);
// node has to be checked out while merging
- nodeToMerge.checkout();
+ VersionManager versionManager = nodeToMerge.getSession().getWorkspace().getVersionManager();
+ versionManager.checkout(nodeToMerge.getPath());
}
protected void tearDown() throws Exception {
@@ -96,18 +98,70 @@
}
/**
+ * Merge.cancelMerge(V): has the effect of removing the reference to V' from
+ * the jcr:mergeFailed property of N.
without adding it to
+ * jcr:predecessors.
Branches will not be joined.
+ */
+ public void testMergeNodeCancelMergeJcr2() throws RepositoryException {
+ // create 2 independent versions for a node and its corresponding node
+ // so merge fails for this node
+
+ // default workspace
+ Node originalNode = testRootNode.getNode(nodeName1);
+ VersionManager vmWsp1 = originalNode.getSession().getWorkspace().getVersionManager();
+ String originalPath = originalNode.getPath();
+ vmWsp1.checkout(originalPath);
+ vmWsp1.checkin(originalPath);
+
+ // second workspace
+ VersionManager vmWsp2 = nodeToMerge.getSession().getWorkspace().getVersionManager();
+ String path = nodeToMerge.getPath();
+ vmWsp2.checkin(path);
+
+ // "merge" the clonedNode with the newNode from the default workspace
+ vmWsp2.checkout(path);
+ vmWsp2.merge(path, workspace.getName(), true);
+
+ // get predecessors
+ Version[] predecessors = vmWsp2.getBaseVersion(path).getPredecessors();
+ // get mergeFailed property
+ Property mergeFailedProperty = nodeToMerge.getProperty(jcrMergeFailed);
+ Value[] mergeFailedReferences = mergeFailedProperty.getValues();
+
+ for (int i = 0; i < mergeFailedReferences.length; i++) {
+ String id = mergeFailedReferences[i].getString();
+ vmWsp2.cancelMerge(path, (Version) superuser.getNodeByIdentifier(id));
+ }
+
+ // check predecessors - unchanged
+ Version[] predecessorsAfterCancel = vmWsp2.getBaseVersion(path).getPredecessors();
+ assertTrue(predecessors.length == predecessorsAfterCancel.length);
+
+ // check mergeFailed property - reference removed
+ if (nodeToMerge.hasProperty(jcrMergeFailed)) {
+ Property mergeFailedPropertyAfterCancelMerge = nodeToMerge.getProperty(jcrMergeFailed);
+ Value[] mergeFailedReferencesAfterCancelMerge = mergeFailedPropertyAfterCancelMerge.getValues();
+ assertTrue(mergeFailedReferences.length > mergeFailedReferencesAfterCancelMerge.length);
+ }
+ }
+
+ /**
* initialize a versionable node on default and second workspace
*/
protected void initNodes() throws RepositoryException {
+
+ VersionManager versionManager = testRootNode.getSession().getWorkspace().getVersionManager();
+
// create a versionable node
// nodeName1
Node topVNode = testRootNode.addNode(nodeName1, versionableNodeType);
topVNode.setProperty(propertyName1, topVNode.getName());
+ String path = topVNode.getPath();
// save default workspace
- testRootNode.save();
- topVNode.checkin();
- topVNode.checkout();
+ testRootNode.getSession().save();
+ versionManager.checkin(path);
+ versionManager.checkout(path);
log.println("test nodes created successfully on " + workspace.getName());
Index: jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/MergeDoneMergeTest.java
===================================================================
--- jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/MergeDoneMergeTest.java (revision 776807)
+++ jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/MergeDoneMergeTest.java (working copy)
@@ -21,6 +21,7 @@
import javax.jcr.RepositoryException;
import javax.jcr.Value;
import javax.jcr.version.Version;
+import javax.jcr.version.VersionManager;
/**
* MergeDoneMergeTest contains test dealing with nodes on which
@@ -42,7 +43,8 @@
nodeToMerge = testRootNodeW2.getNode(nodeName1);
// node has to be checked out while merging
- nodeToMerge.checkout();
+ VersionManager versionManager = nodeToMerge.getSession().getWorkspace().getVersionManager();
+ versionManager.checkout(nodeToMerge.getPath());
}
@@ -92,18 +94,66 @@
}
/**
+ * VersionManager.doneMerge(V) throws VersionException if V is not among the Vs in the
+ * jcr:mergeFailed prop.
with adding it to jcr:predecessors.
+ * Branches will be joined.
+ */
+ public void testMergeNodeDoneMergeJcr2() throws RepositoryException {
+ // create 2 independent versions for a node and its corresponding node
+ // so merge fails for this node
+
+ // default workspace
+ Node originalNode = testRootNode.getNode(nodeName1);
+ VersionManager vmWsp1 = originalNode.getSession().getWorkspace().getVersionManager();
+ String originalPath = originalNode.getPath();
+ vmWsp1.checkout(originalPath);
+ vmWsp1.checkin(originalPath);
+
+ // second workspace
+ VersionManager vmWsp2 = nodeToMerge.getSession().getWorkspace().getVersionManager();
+ String path = nodeToMerge.getPath();
+ vmWsp2.checkin(path);
+
+ // "merge" the clonedNode with the newNode from the default workspace
+ vmWsp2.checkout(path);
+ vmWsp2.merge(path, workspace.getName(), true);
+
+ // get predecessors
+ Version[] predecessors = nodeToMerge.getBaseVersion().getPredecessors();
+ // get mergeFailed property
+ Property mergeFailedProperty = nodeToMerge.getProperty(jcrMergeFailed);
+ Value[] mergeFailedReferences = mergeFailedProperty.getValues();
+
+ for (int i = 0; i < mergeFailedReferences.length; i++) {
+ String id = mergeFailedReferences[i].getString();
+ vmWsp2.doneMerge(path, (Version) superuser.getNodeByIdentifier(id));
+ }
+
+ // check mergeFailed property - reference moved to predecessor
+ if (nodeToMerge.hasProperty(jcrMergeFailed)) {
+ Property mergeFailedPropertyAfterCancelMerge = nodeToMerge.getProperty(jcrMergeFailed);
+ Value[] mergeFailedReferencesAfterCancelMerge = mergeFailedPropertyAfterCancelMerge.getValues();
+ assertTrue(mergeFailedReferences.length > mergeFailedReferencesAfterCancelMerge.length);
+ }
+ }
+
+ /**
* initialize a versionable node on default and second workspace
*/
protected void initNodes() throws RepositoryException {
+
+ VersionManager versionManager = testRootNode.getSession().getWorkspace().getVersionManager();
+
// create a versionable node
// nodeName1
Node topVNode = testRootNode.addNode(nodeName1, versionableNodeType);
topVNode.setProperty(propertyName1, topVNode.getName());
+ String path = topVNode.getPath();
// save default workspace
- testRootNode.save();
- topVNode.checkin();
- topVNode.checkout();
+ testRootNode.getSession().save();
+ versionManager.checkin(path);
+ versionManager.checkout(path);
log.println("test nodes created successfully on " + workspace.getName());
Index: jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/OnParentVersionCopyTest.java
===================================================================
--- jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/OnParentVersionCopyTest.java (revision 776807)
+++ jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/OnParentVersionCopyTest.java (working copy)
@@ -20,6 +20,7 @@
import javax.jcr.Node;
import javax.jcr.version.OnParentVersionAction;
import javax.jcr.version.Version;
+import javax.jcr.version.VersionManager;
/**
* OnParentVersionCopyTest tests the OnParentVersion {@link OnParentVersionAction#COPY COPY}
@@ -76,4 +77,35 @@
// todo: add proper comparison of restored node. equals does not work
// assertEquals("On restore of a OnParentVersion-COPY child node, the node needs to be restored, replacing the current node in the workspace.", childNode, superuser.getItem(initialNodePath));
}
+
+ /**
+ * Test the restore of a OnParentVersion-COPY node
+ *
+ * @throws javax.jcr.RepositoryException
+ */
+ public void testRestoreNodeJcr2() throws RepositoryException {
+ // prepare for node test
+ Node childNode = addChildNode(OPVAction);
+ Node nodeParent = childNode.getParent();
+ // todo: added next line. correct? -> angela
+ nodeParent.getSession().save();
+
+ VersionManager versionManager = nodeParent.getSession().getWorkspace().getVersionManager();
+ String path = nodeParent.getPath();
+ versionManager.checkout(path);
+ Version v = versionManager.checkin(path);
+
+ initialNodePath = childNode.getPath();
+ versionManager.checkout(path);
+ childNode.remove();
+ nodeParent.getSession().save();
+
+ versionManager.restore(v, false);
+
+ if (!superuser.itemExists(initialNodePath)) {
+ fail("On restore of a OnParentVersion-COPY child node, the node needs to be restored, replacing the current node in the workspace.");
+ }
+ // todo: add proper comparison of restored node. equals does not work
+ // assertEquals("On restore of a OnParentVersion-COPY child node, the node needs to be restored, replacing the current node in the workspace.", childNode, superuser.getItem(initialNodePath));
+ }
}
\ No newline at end of file
Index: jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/GetReferencesNodeTest.java
===================================================================
--- jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/GetReferencesNodeTest.java (revision 776807)
+++ jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/GetReferencesNodeTest.java (working copy)
@@ -20,6 +20,7 @@
import javax.jcr.PropertyIterator;
import javax.jcr.PropertyType;
import javax.jcr.RepositoryException;
+import javax.jcr.version.VersionManager;
import org.apache.jackrabbit.test.AbstractJCRTest;
import org.apache.jackrabbit.test.NotExecutableException;
@@ -73,19 +74,21 @@
// create some test nodes
initTestNodes();
+ VersionManager versionManager = testNode.getSession().getWorkspace().getVersionManager();
+ String path = testNode.getPath();
// create a version 1.0 and reference test node
- testNode.checkout();
+ versionManager.checkout(path);
ensureCanSetProperty(testNode, propertyName1, PropertyType.REFERENCE, false);
testNode.setProperty(propertyName1, nodeToBeReferenced);
- testRootNode.save();
- testNode.checkin();
+ testRootNode.getSession().save();
+ versionManager.checkin(path);
// create a version 1.1 and remove reference
- testNode.checkout();
+ versionManager.checkout(path);
testNode.getProperty(propertyName1).remove();
- testRootNode.save();
- testNode.checkin();
+ testRootNode.getSession().save();
+ versionManager.checkin(path);
// check if reference is returned
boolean nodeToBeReferencedIsReference = false;
@@ -108,6 +111,6 @@
// node to be referenced, does not have to be versionable
nodeToBeReferenced = testRootNode.addNode(nodeName2, versionableNodeType);
- testRootNode.save();
+ testRootNode.getSession().save();
}
}
\ No newline at end of file