You are viewing a plain text version of this content. The canonical link for it is here.
Posted to oak-commits@jackrabbit.apache.org by tr...@apache.org on 2013/11/15 23:09:31 UTC
svn commit: r1542418 - in /jackrabbit/oak/trunk/oak-jcr: pom.xml
src/test/java/org/apache/jackrabbit/oak/jcr/ConcurrentAddReferenceTest.java
src/test/java/org/apache/jackrabbit/oak/jcr/ReferencesTest.java
Author: tripod
Date: Fri Nov 15 22:09:31 2013
New Revision: 1542418
URL: http://svn.apache.org/r1542418
Log:
Adding references test
Added:
jackrabbit/oak/trunk/oak-jcr/src/test/java/org/apache/jackrabbit/oak/jcr/ConcurrentAddReferenceTest.java
jackrabbit/oak/trunk/oak-jcr/src/test/java/org/apache/jackrabbit/oak/jcr/ReferencesTest.java
Modified:
jackrabbit/oak/trunk/oak-jcr/pom.xml
Modified: jackrabbit/oak/trunk/oak-jcr/pom.xml
URL: http://svn.apache.org/viewvc/jackrabbit/oak/trunk/oak-jcr/pom.xml?rev=1542418&r1=1542417&r2=1542418&view=diff
==============================================================================
--- jackrabbit/oak/trunk/oak-jcr/pom.xml (original)
+++ jackrabbit/oak/trunk/oak-jcr/pom.xml Fri Nov 15 22:09:31 2013
@@ -50,6 +50,13 @@
org.apache.jackrabbit.test.api.WorkspaceMoveSameNameSibsTest#testMoveNodesOrderingSupportedByParent <!-- OAK-118 -->
org.apache.jackrabbit.test.api.WorkspaceMoveTest#testMoveNodesLocked <!-- OAK-118 -->
+ org.apache.jackrabbit.oak.jcr.ReferencesTest#testMultipleReferencesOnSameNode <!-- OAK-1194 -->
+ org.apache.jackrabbit.oak.jcr.ReferencesTest#testVersionReferencesV0 <!-- OAK-1194 -->
+ org.apache.jackrabbit.oak.jcr.ReferencesTest#testVersionReferencesV1 <!-- OAK-1194 -->
+ org.apache.jackrabbit.oak.jcr.ReferencesTest#testMovedReferences <!-- OAK-1195 -->
+ org.apache.jackrabbit.oak.jcr.ReferencesTest#testMovedVersionedReferences <!-- OAK-1195 -->
+ org.apache.jackrabbit.oak.jcr.ReferencesTest#testVersionedReferences <!-- OAK-1196 -->
+
<!-- Locking : not fully implemented -->
org.apache.jackrabbit.test.api.lock.LockTest#testNodeLocked
org.apache.jackrabbit.test.api.lock.LockTest#testParentChildDeepLock
Added: jackrabbit/oak/trunk/oak-jcr/src/test/java/org/apache/jackrabbit/oak/jcr/ConcurrentAddReferenceTest.java
URL: http://svn.apache.org/viewvc/jackrabbit/oak/trunk/oak-jcr/src/test/java/org/apache/jackrabbit/oak/jcr/ConcurrentAddReferenceTest.java?rev=1542418&view=auto
==============================================================================
--- jackrabbit/oak/trunk/oak-jcr/src/test/java/org/apache/jackrabbit/oak/jcr/ConcurrentAddReferenceTest.java (added)
+++ jackrabbit/oak/trunk/oak-jcr/src/test/java/org/apache/jackrabbit/oak/jcr/ConcurrentAddReferenceTest.java Fri Nov 15 22:09:31 2013
@@ -0,0 +1,132 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.jackrabbit.oak.jcr;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+import javax.jcr.Node;
+import javax.jcr.RepositoryException;
+import javax.jcr.Session;
+import javax.jcr.nodetype.NodeType;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import com.google.common.collect.Iterators;
+
+import static org.apache.jackrabbit.commons.JcrUtils.in;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+/**
+ * <code>ConcurrentAddIT</code> adds nodes with multiple sessions in separate
+ * locations of the repository and creates references to a single node.
+ */
+public class ConcurrentAddReferenceTest extends AbstractRepositoryTest {
+
+ private static final int NUM_WORKERS = 10;
+
+ private static final int NODES_PER_WORKER = 100;
+
+ private String refPath;
+
+ public ConcurrentAddReferenceTest(NodeStoreFixture fixture) {
+ super(fixture);
+ }
+
+ @Before
+ public void setup() throws RepositoryException {
+ Session session = getAdminSession();
+ Node root = session.getRootNode();
+ Node testNode = root.addNode("test_referenceable");
+ testNode.addMixin(NodeType.MIX_REFERENCEABLE);
+ session.save();
+ refPath = testNode.getPath();
+ }
+
+ @After
+ public void tearDown() throws RepositoryException {
+ Session session = getAdminSession();
+ session.removeItem("/test");
+ session.removeItem(refPath);
+ session.save();
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ @Ignore("OAK-1137")
+ public void addReferences() throws Exception {
+ List<Exception> exceptions = Collections.synchronizedList(new ArrayList<Exception>());
+ Node test = getAdminSession().getRootNode().addNode("test");
+ List<Thread> worker = new ArrayList<Thread>();
+ for (int i = 0; i < NUM_WORKERS; i++) {
+ String path = test.addNode("node" + i).getPath();
+ worker.add(new Thread(new Worker(
+ createAdminSession(), path, exceptions)));
+ }
+ getAdminSession().save();
+ for (Thread t : worker) {
+ t.start();
+ }
+ for (Thread t : worker) {
+ t.join();
+ }
+ for (Exception e : exceptions) {
+ fail(e.toString());
+ }
+ getAdminSession().refresh(false);
+ for (Node n : in((Iterator<Node>) test.getNodes())) {
+ assertEquals(NODES_PER_WORKER, Iterators.size(n.getNodes()));
+ }
+ }
+
+ private final class Worker implements Runnable {
+
+ private final Session s;
+ private final String path;
+ private final List<Exception> exceptions;
+
+ Worker(Session s, String path, List<Exception> exceptions) {
+ this.s = s;
+ this.path = path;
+ this.exceptions = exceptions;
+ }
+
+ @Override
+ public void run() {
+ try {
+ s.refresh(false);
+ Node n = s.getNode(path);
+ Node refNode = s.getNode(refPath);
+ for (int i = 0; i < NODES_PER_WORKER; i++) {
+ Node n1 = n.addNode("node" + i);
+ n1.setProperty("myRef", refNode);
+ s.save();
+ }
+ } catch (RepositoryException e) {
+ exceptions.add(e);
+ } finally {
+ s.logout();
+ }
+ }
+ }
+}
Added: jackrabbit/oak/trunk/oak-jcr/src/test/java/org/apache/jackrabbit/oak/jcr/ReferencesTest.java
URL: http://svn.apache.org/viewvc/jackrabbit/oak/trunk/oak-jcr/src/test/java/org/apache/jackrabbit/oak/jcr/ReferencesTest.java?rev=1542418&view=auto
==============================================================================
--- jackrabbit/oak/trunk/oak-jcr/src/test/java/org/apache/jackrabbit/oak/jcr/ReferencesTest.java (added)
+++ jackrabbit/oak/trunk/oak-jcr/src/test/java/org/apache/jackrabbit/oak/jcr/ReferencesTest.java Fri Nov 15 22:09:31 2013
@@ -0,0 +1,249 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.jackrabbit.oak.jcr;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+
+import javax.jcr.ItemNotFoundException;
+import javax.jcr.Node;
+import javax.jcr.Property;
+import javax.jcr.PropertyIterator;
+import javax.jcr.RepositoryException;
+import javax.jcr.Value;
+import javax.jcr.version.Version;
+import javax.jcr.version.VersionHistory;
+import javax.jcr.version.VersionManager;
+
+import org.apache.jackrabbit.test.AbstractJCRTest;
+
+/**
+ * Some very special reference tests also including references into the version store.
+ */
+public class ReferencesTest extends AbstractJCRTest {
+
+ public void testSimpleReferences() throws RepositoryException {
+ Node ref = testRootNode.addNode(nodeName2, testNodeType);
+ ref.addMixin(mixReferenceable);
+ superuser.save();
+
+ Node n = testRootNode.addNode(nodeName1, testNodeType);
+ n.setProperty("myref", ref);
+ superuser.save();
+
+ assertEquals("ref", ref.getPath(), n.getProperty("myref").getNode().getPath());
+ checkReferences("refs", ref, n.getPath() + "/myref");
+ }
+
+ // OAK-1194 Missing properties in Node.getReferences()
+ public void testMultipleReferencesOnSameNode() throws RepositoryException {
+ Node ref = testRootNode.addNode(nodeName2, testNodeType);
+ ref.addMixin(mixReferenceable);
+ superuser.save();
+
+ Node n = testRootNode.addNode(nodeName1, testNodeType);
+ n.setProperty("myref0", ref);
+ n.setProperty("myref1", ref);
+ superuser.save();
+
+ assertEquals("ref", ref.getPath(), n.getProperty("myref0").getNode().getPath());
+ assertEquals("ref", ref.getPath(), n.getProperty("myref1").getNode().getPath());
+
+ checkReferences("refs", ref, n.getPath() + "/myref0", n.getPath() + "/myref1");
+ }
+
+ public void testMultipleReferences() throws RepositoryException {
+ Node ref = testRootNode.addNode(nodeName2, testNodeType);
+ ref.addMixin(mixReferenceable);
+ superuser.save();
+
+ Node n0 = testRootNode.addNode(nodeName1, testNodeType);
+ n0.setProperty("myref", ref);
+ Node n1 = testRootNode.addNode(nodeName3, testNodeType);
+ n1.setProperty("myref", ref);
+ superuser.save();
+
+ checkReferences("refs", ref, n0.getPath() + "/myref", n1.getPath() + "/myref");
+ }
+
+ // OAK-1195 Unable to move referenced mode
+ public void testMovedReferences() throws RepositoryException {
+ Node ref = testRootNode.addNode(nodeName2, testNodeType);
+ ref.addMixin(mixReferenceable);
+ superuser.save();
+
+ Node n = testRootNode.addNode(nodeName1, testNodeType);
+ n.setProperty("myref", ref);
+ superuser.save();
+
+ String newPath = testRootNode.getPath() + "/" + nodeName3;
+ superuser.move(ref.getPath(), newPath);
+ superuser.save();
+ ref = superuser.getNode(newPath);
+ assertEquals("ref", ref.getPath(), n.getProperty("myref").getNode().getPath());
+ checkReferences("refs", ref, n.getPath() + "/myref");
+ }
+
+ public void testMVReferences() throws RepositoryException {
+ Node ref0 = testRootNode.addNode(nodeName2, testNodeType);
+ ref0.addMixin(mixReferenceable);
+ Node ref1 = testRootNode.addNode(nodeName3, testNodeType);
+ ref1.addMixin(mixReferenceable);
+ superuser.save();
+
+ Node n = testRootNode.addNode(nodeName1, testNodeType);
+ Value[] vs = new Value[]{
+ superuser.getValueFactory().createValue(ref0),
+ superuser.getValueFactory().createValue(ref1)
+ };
+ n.setProperty("myref", vs);
+ superuser.save();
+
+ assertEquals("ref0", ref0.getIdentifier(), n.getProperty("myref").getValues()[0].getString());
+ assertEquals("ref1", ref1.getIdentifier(), n.getProperty("myref").getValues()[1].getString());
+ checkReferences("refs", ref0, n.getPath() + "/myref");
+ checkReferences("refs", ref1, n.getPath() + "/myref");
+ }
+
+ public void testVersionReferencesVH() throws RepositoryException {
+ Node n = testRootNode.addNode(nodeName1, testNodeType);
+ n.addMixin(mixVersionable);
+ superuser.save();
+
+ String p = n.getPath();
+ VersionManager vMgr = superuser.getWorkspace().getVersionManager();
+ VersionHistory vh = vMgr.getVersionHistory(p);
+
+ // check if versionable node has references to root version
+ assertEquals("Version History", vh.getIdentifier(), n.getProperty(Property.JCR_VERSION_HISTORY).getString());
+
+ checkReferences("Version History", vh, p + "/jcr:versionHistory");
+ }
+
+ public void testVersionReferencesV0() throws RepositoryException {
+ Node n = testRootNode.addNode(nodeName1, testNodeType);
+ n.addMixin(mixVersionable);
+ superuser.save();
+
+ String p = n.getPath();
+ VersionManager vMgr = superuser.getWorkspace().getVersionManager();
+ Version v0 = vMgr.getVersionHistory(p).getRootVersion();
+
+ // check if versionable node has references to root version
+ assertEquals("Root Version", v0.getIdentifier(), n.getProperty(Property.JCR_BASE_VERSION).getString());
+ assertEquals("Root Version", v0.getIdentifier(), n.getProperty(Property.JCR_PREDECESSORS).getValues()[0].getString());
+
+ checkReferences("Root Version", v0,
+ p + "/jcr:baseVersion",
+ p + "/jcr:predecessors"
+ );
+ }
+
+ public void testVersionReferencesV1() throws RepositoryException {
+ Node n = testRootNode.addNode(nodeName1, testNodeType);
+ n.addMixin(mixVersionable);
+ superuser.save();
+
+ String p = n.getPath();
+ VersionManager vMgr = superuser.getWorkspace().getVersionManager();
+ Version v1 = vMgr.checkpoint(p);
+
+ // check if versionable node has references to v1.0
+ assertEquals("v1.0", v1.getIdentifier(), n.getProperty(Property.JCR_BASE_VERSION).getString());
+ assertEquals("v1.0", v1.getIdentifier(), n.getProperty(Property.JCR_PREDECESSORS).getValues()[0].getString());
+
+ checkReferences("v1.0", v1,
+ p + "/jcr:baseVersion",
+ p + "/jcr:predecessors"
+ );
+ }
+
+ // OAK-1196 - Node.getReferences() should not show references in frozen nodes
+ public void testVersionedReferences() throws RepositoryException {
+ Node ref = testRootNode.addNode(nodeName2, testNodeType);
+ ref.addMixin(mixReferenceable);
+ superuser.save();
+
+ Node n = testRootNode.addNode(nodeName1, testNodeType);
+ n.addMixin(mixVersionable);
+ n.setProperty("myref", ref);
+ superuser.save();
+
+ String p = n.getPath();
+ VersionManager vMgr = superuser.getWorkspace().getVersionManager();
+ Version v1 = vMgr.checkpoint(p);
+ Node frozen = v1.getFrozenNode();
+
+ assertEquals("ref", ref.getPath(), frozen.getProperty("myref").getNode().getPath());
+
+ checkReferences("ref in version store", ref, n.getPath() + "/myref");
+
+ // also test what happens if node is removed
+ n.remove();
+ ref.remove();
+ superuser.save();
+
+ try {
+ frozen.getProperty("myref").getNode();
+ fail("removed reference should not be accessible");
+ } catch (ItemNotFoundException e) {
+ // ok
+ }
+ }
+
+ public void testMovedVersionedReferences() throws RepositoryException {
+ Node ref = testRootNode.addNode(nodeName2, testNodeType);
+ ref.addMixin(mixReferenceable);
+ superuser.save();
+
+ Node n = testRootNode.addNode(nodeName1, testNodeType);
+ n.addMixin(mixVersionable);
+ n.setProperty("myref", ref);
+ superuser.save();
+
+ String p = n.getPath();
+ VersionManager vMgr = superuser.getWorkspace().getVersionManager();
+ Version v1 = vMgr.checkpoint(p);
+
+ String newPath = testRootNode.getPath() + "/" + nodeName3;
+ superuser.move(ref.getPath(), newPath);
+ superuser.save();
+ ref = superuser.getNode(newPath);
+
+ Node frozen = v1.getFrozenNode();
+ assertEquals("ref", ref.getPath(), frozen.getProperty("myref").getNode().getPath());
+ checkReferences("ref in version store", ref, n.getPath() + "/myref");
+ }
+
+ private static void checkReferences(String msg, Node node, String ... expected) throws RepositoryException {
+ PropertyIterator iter = node.getReferences();
+ List<String> paths = new LinkedList<String>();
+ while (iter.hasNext()) {
+ paths.add(iter.nextProperty().getPath());
+ }
+ checkEquals(msg, paths, expected);
+ }
+
+ private static void checkEquals(String msg, List<String> result, String ... expected) {
+ List<String> exp = Arrays.asList(expected);
+ Collections.sort(result);
+ Collections.sort(exp);
+ assertEquals(msg, exp.toString(), result.toString());
+ }
+}