/*
* Copyright (C) 2009 eXo Platform SAS.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.exoplatform.services.jcr.api.reading;
import org.exoplatform.services.jcr.JcrAPIBaseTest;
import org.exoplatform.services.jcr.access.PermissionType;
import org.exoplatform.services.jcr.core.CredentialsImpl;
import org.exoplatform.services.jcr.impl.core.NodeImpl;
import org.exoplatform.services.jcr.impl.core.SessionImpl;
import org.exoplatform.services.jcr.impl.core.nodetype.NodeTypeImpl;
import org.exoplatform.services.jcr.impl.core.value.BinaryValue;
import org.exoplatform.services.jcr.impl.core.value.StringValue;
import org.exoplatform.services.jcr.impl.dataflow.SpoolConfig;
import java.io.ByteArrayInputStream;
import java.security.AccessControlException;
import java.util.Calendar;
import java.util.HashMap;
import javax.jcr.AccessDeniedException;
import javax.jcr.InvalidItemStateException;
import javax.jcr.Item;
import javax.jcr.ItemExistsException;
import javax.jcr.ItemNotFoundException;
import javax.jcr.NoSuchWorkspaceException;
import javax.jcr.Node;
import javax.jcr.NodeIterator;
import javax.jcr.PathNotFoundException;
import javax.jcr.Property;
import javax.jcr.PropertyIterator;
import javax.jcr.PropertyType;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.jcr.UnsupportedRepositoryOperationException;
import javax.jcr.Value;
import javax.jcr.lock.LockException;
import javax.jcr.nodetype.ConstraintViolationException;
import javax.jcr.nodetype.NoSuchNodeTypeException;
import javax.jcr.version.VersionException;
/**
* Created by The eXo Platform SAS.
*
* @author <a href="mailto:geaz@users.sourceforge.net">Gennady Azarenkov</a>
* @version $Id: TestNode.java 11907 2008-03-13 15:36:21Z ksm $
*/
public class TestNode extends JcrAPIBaseTest
{
private Node testRoot;
public void initRepository() throws RepositoryException
{
Node root = session.getRootNode();
Node file = root.addNode("childNode", "nt:folder").addNode("childNode2", "nt:file");
Node contentNode = file.addNode("jcr:content", "nt:resource");
contentNode = file.getNode("jcr:content");
contentNode.setProperty("jcr:data", session.getValueFactory().createValue("this is the content",
PropertyType.BINARY));
contentNode.setProperty("jcr:mimeType", session.getValueFactory().createValue("text/html"));
contentNode.setProperty("jcr:lastModified", session.getValueFactory().createValue(Calendar.getInstance()));
session.save();
}
public void tearDown() throws Exception
{
Node root = session.getRootNode();
Node node = root.getNode("childNode");
node.remove();
session.save();
super.tearDown();
}
public void testGetNode() throws Exception
{
Node root = session.getRootNode();
try
{
root.getNode("/childNode/childNode2");
fail("exception should have been thrown - not rel path");
}
catch (RepositoryException e)
{
}
Node node = root.getNode("childNode/childNode2");
assertNotNull(node);
assertEquals("nt:file", node.getPrimaryNodeType().getName());
Property property = node.getNode("jcr:content").getProperty("jcr:data");
property.setValue(new StringValue("this is the NEW content"));
node = root.getNode("childNode");
node.addNode("childNode3", "nt:file");
session = (SessionImpl)repository.login(credentials, WORKSPACE);
root = session.getRootNode();
try
{
Node n = root.getNode("childNode/childNode3");
fail("exception should have been thrown " + n);
}
catch (RepositoryException e)
{
}
property = root.getNode("childNode/childNode2/jcr:content").getProperty("jcr:data");
assertEquals("this is the content", property.getString());
Value val =
new BinaryValue(new ByteArrayInputStream("this is the NEW content".getBytes()),
SpoolConfig.getDefaultSpoolConfig());
node = root.getNode("childNode/childNode2/jcr:content");
node.setProperty("jcr:data", val);
// property.setValue(val);
node = root.getNode("childNode");
session.save();
root = repository.login(credentials, WORKSPACE).getRootNode();
// System.out.println("------------------");
property = root.getNode("childNode/childNode2/jcr:content").getProperty("jcr:data");
assertEquals("this is the NEW content", property.getString());
session = (SessionImpl)repository.login(credentials, WORKSPACE);
root = session.getRootNode();
node = root.getNode("childNode");
assertEquals(node.toString(), root.getNode("childNode").toString());
// not allowed!
// root.getNode("childNode/childNode2/jcr:content").setProperty("myapp:temp",
// new
// StringValue("Temp"));
Session session2 = repository.login(credentials, WORKSPACE);
Node root2 = session2.getRootNode();
Node node2 = root2.getNode("childNode/childNode2/jcr:content");
node2.setProperty("jcr:data",
new BinaryValue(new ByteArrayInputStream("Temp".getBytes()), SpoolConfig.getDefaultSpoolConfig()));
session2.save();
session.refresh(false);
root = session.getRootNode();
node = root.getNode("childNode/childNode2/jcr:content");
assertNotNull(node);
assertNotNull(node.getProperty("jcr:data"));
assertEquals("Temp", node.getProperty("jcr:data").getString());
try
{
node.getProperty("myapp:temp");
fail("exception should have been thrown");
}
catch (RepositoryException e)
{
}
}
public void testGetSomeSiblingNode() throws RepositoryException
{
root = session.getRootNode();
Node subRoot = root.addNode("subRoot", "nt:unstructured");
Node child1 = subRoot.addNode("child", "nt:unstructured");
child1.setProperty("prop1", "prop1");
Node child2 = subRoot.addNode("child", "nt:unstructured");
child2.setProperty("prop2", "prop2");
Node child3 = subRoot.addNode("child", "nt:unstructured");
assertEquals(1, child1.getIndex());
assertTrue(child1.hasProperty("prop1"));
assertEquals(2, child2.getIndex());
assertTrue(child2.hasProperty("prop2"));
assertEquals(3, child3.getIndex());
root.save();
// System.out.println(">>"+session.getContainer());
subRoot = root.getNode("subRoot");
child1 = subRoot.getNode("child");
assertEquals(1, child1.getIndex());
assertTrue(child1.hasProperty("prop1"));
NodeIterator children = subRoot.getNodes();
assertEquals(3, (int)children.getSize());
child1 = (Node)children.next();
assertEquals(1, child1.getIndex());
assertTrue(child1.hasProperty("prop1"));
child2 = (Node)children.next();
assertEquals(2, child2.getIndex());
assertTrue(child2.hasProperty("prop2"));
// read first same name sibling
child1 = (Node)session.getItem("/subRoot/child");
assertEquals("Not returned first item", 1, child1.getIndex());
subRoot.remove();
root.save();
// subRoot.save(); ipossible to call save() on removed node
}
public void testGetNodes() throws RepositoryException
{
session = (SessionImpl)repository.login(credentials, WORKSPACE);
Node root = session.getRootNode();
Node node = root.getNode("childNode");
log.debug("ChildNode before refresh " + node);
node.addNode("childNode4", "nt:folder");
NodeIterator nodeIterator = node.getNodes();
while (nodeIterator.hasNext())
{
node = (Node)nodeIterator.next();
assertNotNull(node.getSession());
if (!("childNode4".equals(node.getName()) || "childNode2".equals(node.getName())))
fail("returned non expected nodes" + node.getName() + " " + node);
}
Session session2 = repository.login(credentials, WORKSPACE);
Node root2 = session2.getRootNode();
Node node2 = root2.getNode("childNode");
Node node5 = node2.addNode("childNode5", "nt:folder");
session2.save();
session.refresh(false);
node = root.getNode("childNode");
// log.debug("ChildNode after refresh "+node+" "+((NodeImpl)node).isChildNodesInitialized());
nodeIterator = node.getNodes();
while (nodeIterator.hasNext())
{
node = (Node)nodeIterator.next();
if (!("childNode5".equals(node.getName()) || "childNode2".equals(node.getName())))
fail("returned non expected nodes " + node.getName() + " " + node);
}
node5.remove();
session2.save();
}
public void testGetNodesWithNamePattern() throws RepositoryException
{
session = (SessionImpl)repository.login(credentials, WORKSPACE);
Node root = session.getRootNode();
Node node = root.getNode("childNode");
node.addNode("childNode4", "nt:folder");
node.addNode("otherNode", "nt:folder");
node.addNode("lastNode", "nt:folder");
Node result = (Node)node.getNodes("lastNode").next();
assertEquals("lastNode", result.getName());
NodeIterator iterator = node.getNodes("otherNode | lastNode");
if (!iterator.hasNext())
fail("nodes should have been found");
while (iterator.hasNext())
{
Node nodeTmp = iterator.nextNode();
if (!("otherNode".equals(nodeTmp.getName()) || "lastNode".equals(nodeTmp.getName())))
fail("returned non expected nodes");
}
iterator = node.getNodes("childNode*");
if (!iterator.hasNext())
fail("nodes should have been found");
while (iterator.hasNext())
{
Node nodeTmp = iterator.nextNode();
if (!("childNode2".equals(nodeTmp.getName()) || "childNode4".equals(nodeTmp.getName())))
fail("returned non expected nodes");
}
Session session2 = repository.login(credentials, WORKSPACE);
Node root2 = session2.getRootNode();
Node node2 = root2.getNode("childNode");
node2.addNode("childNode5", "nt:folder");
session2.save();
session.refresh(false);
node = root.getNode("childNode");
iterator = node.getNodes("childNode*");
if (!iterator.hasNext())
fail("nodes should have been found");
while (iterator.hasNext())
{
Node nodeTmp = iterator.nextNode();
if (!("childNode2".equals(nodeTmp.getName()) || "childNode5".equals(nodeTmp.getName())))
fail("returned non expected nodes");
}
}
public void testGetProperty() throws RepositoryException
{
final String valueNew = "this is the NEW value";
session = (SessionImpl)repository.login(credentials, WORKSPACE);
Node root = session.getRootNode();
Node node = root.getNode("childNode/childNode2/jcr:content");
Property property = node.getProperty("jcr:data");
assertEquals("this is the content", property.getString());
Session session2 = repository.login(credentials, WORKSPACE);
Node root2 = session2.getRootNode();
Node node2 = root2.getNode("childNode/childNode2/jcr:content");
// log.debug("Set prop");
node2.getProperty("jcr:data").setValue(valueFactory.createValue(valueNew.toString(), PropertyType.BINARY));
// node2.setProperty("jcr:data",
// valueFactory.createValue("this is the NEW value",
// PropertyType.BINARY));
session2.save();
// log.debug("Set prop end");
assertEquals(valueNew.toString(), ((Property)session2.getItem("/childNode/childNode2/jcr:content/jcr:data"))
.getString());
assertEquals("this is the NEW value", root2.getNode("childNode/childNode2/jcr:content").getProperty("jcr:data")
.getString());
Session session3 = repository.login(credentials, WORKSPACE);
Node root3 = session3.getRootNode();
Node node3 = root3.getNode("childNode/childNode2/jcr:content");
assertEquals(valueNew.toString(), ((Property)session3.getItem("/childNode/childNode2/jcr:content/jcr:data"))
.getString());
assertEquals(valueNew.toString(), node3.getProperty("jcr:data").getString());
node.refresh(false);
// session = repository.login(credentials, WORKSPACE);
property = root.getNode("childNode/childNode2/jcr:content").getProperty("jcr:data");
assertEquals("/childNode/childNode2/jcr:content/jcr:data", property.getPath());
assertEquals(valueNew.toString(), property.getString());
}
public void testGetProperties() throws RepositoryException
{
session = (SessionImpl)repository.login(credentials, WORKSPACE);
Node root = session.getRootNode();
Node node = root.getNode("childNode");
PropertyIterator iterator = node.getProperties();
while (iterator.hasNext())
{
Property property = iterator.nextProperty();
if (!("jcr:primaryType".equals(property.getName()) || "jcr:created".equals(property.getName()) || "jcr:lastModified"
.equals(property.getName())))
fail("returned non expected nodes");
}
Session session2 = repository.login(credentials, WORKSPACE);
Node root2 = session2.getRootNode();
Node node2 = root2.getNode("childNode/childNode2/jcr:content");
node2.setProperty("jcr:data", session.getValueFactory().createValue("hehe", PropertyType.BINARY));
session2.save();
session.refresh(false);
node = root.getNode("childNode/childNode2/jcr:content");
iterator = node.getProperties();
while (iterator.hasNext())
{
Property property = iterator.nextProperty();
log.debug("PROP---" + property);
}
}
public void testGetPropertiesWithNamePattern() throws RepositoryException
{
session = (SessionImpl)repository.login(credentials, WORKSPACE);
Node root = session.getRootNode();
// Node node = root.getNode("/childNode/childNode2/jcr:content");
Node node = root.addNode("testNode", "nt:unstructured");
node.setProperty("property1", "prop1Value");
node.setProperty("property2", "prop2Value");
PropertyIterator iterator = node.getProperties("property1 | property2");
while (iterator.hasNext())
{
Property property = iterator.nextProperty();
if (!("property1".equals(property.getName()) || "property2".equals(property.getName())))
fail("returned non expected properties");
}
iterator = node.getProperties("property1 | jcr:*");
while (iterator.hasNext())
{
Property property = iterator.nextProperty();
if (!("property1".equals(property.getName()) || "jcr:primaryType".equals(property.getName())))
fail("returned non expected properties");
}
}
public void testGetPropertiesWithNamePatternStoredData() throws RepositoryException
{
session = (SessionImpl)repository.login(credentials, WORKSPACE);
Node root = session.getRootNode();
// Node node = root.getNode("/childNode/childNode2/jcr:content");
Node node = root.addNode("testNode", "nt:unstructured");
node.setProperty("property1", "prop1Value");
node.setProperty("property2", "prop2Value");
root.save();
PropertyIterator iterator = node.getProperties("property1 | property2");
while (iterator.hasNext())
{
Property property = iterator.nextProperty();
if (!("property1".equals(property.getName()) || "property2".equals(property.getName())))
fail("returned non expected properties");
}
iterator = node.getProperties("property1 | jcr:*");
while (iterator.hasNext())
{
Property property = iterator.nextProperty();
if (!("property1".equals(property.getName()) || "jcr:primaryType".equals(property.getName())))
fail("returned non expected properties");
}
node.setProperty("proper_ty", "prop_value");
node.setProperty("properAty", "propAvalue");
root.save();
iterator = node.getProperties("proper_t%");
while (iterator.hasNext())
{
Property property = iterator.nextProperty();
if (!("proper_ty".equals(property.getName())))
fail("returned non expected properties");
}
}
public void testGetPrimaryItem() throws RepositoryException
{
Node root = session.getRootNode();
try
{
root.getPrimaryItem();
fail("exception should have been thrown");
}
catch (RepositoryException e)
{
assertTrue(e instanceof ItemNotFoundException);
}
Node node = root.getNode("childNode/childNode2");
Item item = node.getPrimaryItem();
assertNotNull(item);
assertEquals("jcr:content", item.getName());
}
public void testGetUUID() throws RepositoryException
{
Node root = session.getRootNode();
try
{
root.getUUID();
fail("exception should have been thrown");
}
catch (UnsupportedRepositoryOperationException e)
{
}
Node node = root.getNode("childNode/childNode2/jcr:content");
assertTrue(session.itemExists("/childNode/childNode2/jcr:content/jcr:uuid"));
assertNotNull(node.getUUID());
}
public void testGetDefinition() throws RepositoryException
{
Node root = session.getRootNode();
assertNotNull(root.getDefinition());
assertEquals("*", root.getNode("childNode").getDefinition().getName());
assertEquals("jcr:content", root.getNode("childNode").getNode("childNode2").getNode("jcr:content")
.getDefinition().getName());
}
public void testHasNode() throws RepositoryException
{
Node root = session.getRootNode();
assertFalse(root.hasNode("dummyNode"));
assertTrue(root.hasNode("childNode"));
// root.getNode("childNode").remove();
// assertFalse(root.hasNode(""));
}
public void testHasNodes() throws RepositoryException
{
Node root = session.getRootNode();
// System.out.println("Node>>>"+session.getItem("/childNode"));
// System.out.println("Node>>>"+root.getNode("childNode"));
// System.out.println("Node>>>"+root.getNodes().next());
assertTrue(root.hasNodes());
// Node node = root.getNode("/childNode/childNode2/jcr:content");
Node node = root.addNode("tempNode", "nt:unstructured");
node = node.addNode("tempNode1", "nt:unstructured");
assertFalse(node.hasNodes());
}
public void testHasProperty() throws RepositoryException
{
Node root = session.getRootNode();
assertFalse(root.hasProperty("dummyProperty"));
assertTrue(root.getNode("childNode").hasProperty("jcr:created"));
}
public void testHasProperties() throws RepositoryException
{
Node root = session.getRootNode();
Node node = root.getNode("childNode");
assertTrue(node.hasProperties());
}
public void testGetNodesWithNamePatternAndSameNameSibs() throws RepositoryException
{
// The standard method for retrieving a set of such nodes is
// Node.getNodes(String namePattern) which returns an iterator
// over all the child nodes of the calling node that have the specified
// pattern (by making namePattern just a name, without wildcards,
// we can get all the nodes with that exact name, see section
Node root = session.getRootNode();
Node node = root.addNode("snTestNode");
node.addNode("sn");
node.addNode("sn");
node.addNode("sn");
NodeIterator i = node.getNodes("sn");
assertEquals(3l, i.getSize());
}
public void testAddMixinWhenNodeIsProtected() throws NoSuchNodeTypeException, VersionException,
LockException, ItemExistsException, PathNotFoundException, RepositoryException
{
try
{
root.addNode("someNode", "exo:myTypeJCR1703").getNode("exo:myChildNode").addMixin("mix:lockable");
fail();
}
catch (ConstraintViolationException e)
{
}
}
public void testCannotAddNodeWithThisRelPath()
{
try
{
root.addNode(".");
fail();
}
catch (RepositoryException e)
{
}
}
public void testCanAddMixinWhenNodeIsProtected() throws NoSuchNodeTypeException, PathNotFoundException,
ItemExistsException, LockException, VersionException, ConstraintViolationException, RepositoryException
{
Node node = root.addNode("someNode", "exo:myTypeJCR1703").getNode("exo:myChildNode");
assertFalse(node.canAddMixin("mix:lockable"));
}
public void testCannotDoCheckinWhenMergeFailedIsSet() throws ItemExistsException, PathNotFoundException,
VersionException, ConstraintViolationException, LockException, RepositoryException
{
Node testNode = root.addNode("testNode");
testNode.setProperty("jcr:mergeFailed", "");
testNode.addMixin("mix:versionable");
session.save();
try
{
testNode.checkin();
fail();
}
catch (VersionException e)
{
}
}
public void testCannotDoCheckinWhenNodeIsLocked() throws ItemExistsException, PathNotFoundException,
VersionException, ConstraintViolationException, LockException, RepositoryException
{
Node testNode = root.addNode("test");
testNode.addMixin("mix:lockable");
testNode.addMixin("mix:versionable");
session.save();
testNode.lock(true, true);
Session session2 =
repository.login(new CredentialsImpl("admin", "admin".toCharArray()), session.getWorkspace().getName());
try
{
session2.getRootNode().getNode("test").checkin();
fail();
}
catch (LockException e)
{
}
finally
{
session2.logout();
testNode.unlock();
}
}
public void testCannotClearACLForNotExoPrivilegeableNode() throws ItemExistsException, PathNotFoundException,
VersionException, ConstraintViolationException, LockException, RepositoryException
{
try
{
((NodeImpl)root.addNode("testNode")).clearACL();
fail();
}
catch (AccessControlException e)
{
}
}
public void testEquals() throws ItemExistsException, PathNotFoundException, VersionException,
ConstraintViolationException, LockException, RepositoryException
{
assertFalse(root.addNode("testNode").equals(new Object()));
}
public void testCannotGetBaseVersionForNotVersionableNode() throws Exception
{
try
{
root.addNode("testNode").getBaseVersion();
fail();
}
catch (UnsupportedRepositoryOperationException e)
{
}
}
public void testLockWithIsSessionScopedWhenUnsavedChanges() throws UnsupportedRepositoryOperationException,
LockException, AccessDeniedException, ItemExistsException, PathNotFoundException, VersionException,
ConstraintViolationException, RepositoryException
{
NodeImpl testNode = (NodeImpl)root.addNode("testNode");
testNode.addMixin("mix:lockable");
try
{
testNode.lock(true, false);
fail();
}
catch (InvalidItemStateException e)
{
}
}
public void testLockWithTimeOutScopedWhenUnsavedChanges() throws ItemExistsException, PathNotFoundException,
VersionException, ConstraintViolationException, LockException, RepositoryException
{
NodeImpl testNode = (NodeImpl)root.addNode("testNode");
testNode.addMixin("mix:lockable");
try
{
testNode.lock(true, 10L);
fail();
}
catch (InvalidItemStateException e)
{
}
}
public void testLockWithTimeOutScopedWhenLockException() throws ItemExistsException, PathNotFoundException,
VersionException, ConstraintViolationException, LockException, RepositoryException
{
NodeImpl testNode = (NodeImpl)root.addNode("testNode");
testNode.addMixin("mix:lockable");
session.save();
testNode.lock(true, false);
try
{
testNode.lock(true, 10L);
fail();
}
catch (LockException e)
{
}
}
public void testCannotRemovePermissionForNotExoPrivileageableNode() throws ItemExistsException,
PathNotFoundException, VersionException, ConstraintViolationException, LockException, RepositoryException
{
NodeImpl testNode = (NodeImpl)root.addNode("testNode");
NodeImpl testChildNode = (NodeImpl)testNode.addNode("testChildNode");
try
{
testNode.removePermission(testChildNode.getIdentifier());
fail();
}
catch (AccessControlException e)
{
}
try
{
testNode.removePermission(testChildNode.getIdentifier(), "jonh");
fail();
}
catch (AccessControlException e)
{
}
}
public void testSetPermission() throws ItemExistsException, PathNotFoundException, VersionException,
ConstraintViolationException, LockException, RepositoryException
{
NodeImpl testNode = (NodeImpl)root.addNode("testNode");
try
{
testNode.setPermission("john", PermissionType.ALL);
fail();
}
catch (AccessControlException e)
{
}
testNode.addMixin("exo:privilegeable");
session.save();
try
{
testNode.setPermission(null, PermissionType.ALL);
fail();
}
catch (RepositoryException e)
{
}
try
{
testNode.setPermission("john", null);
fail();
}
catch (RepositoryException e)
{
}
}
public void testSetPermissions() throws ItemExistsException, PathNotFoundException, VersionException,
ConstraintViolationException, LockException, RepositoryException
{
NodeImpl testNode = (NodeImpl)root.addNode("testNode");
HashMap<String, String[]> permissions = new HashMap<String, String[]>();
try
{
testNode.setPermissions(permissions);
fail();
}
catch (AccessControlException e)
{
}
testNode.addMixin("exo:privilegeable");
session.save();
permissions.put(null, PermissionType.ALL);
try
{
testNode.setPermissions(permissions);
fail();
}
catch (RepositoryException e)
{
}
permissions.remove(null);
permissions.put("jonh", null);
try
{
testNode.setPermissions(permissions);
fail();
}
catch (RepositoryException e)
{
}
}
public void testUnlockWhenUnsavedChanges() throws ItemExistsException, PathNotFoundException, VersionException,
ConstraintViolationException, LockException, RepositoryException
{
Node someNode = root.addNode("someNode");
someNode.addMixin("mix:lockable");
session.save();
someNode.lock(true, false);
someNode.addNode("temp");
try
{
someNode.unlock();
fail();
}
catch (InvalidItemStateException e)
{
}
}
public void testUpdateNodeIsLocked() throws NoSuchWorkspaceException, AccessDeniedException,
InvalidItemStateException, PathNotFoundException, ItemExistsException, NoSuchNodeTypeException, VersionException,
ConstraintViolationException, RepositoryException
{
Node someNode = root.addNode("someNode");
someNode.addMixin("mix:lockable");
session.save();
someNode.lock(true, false);
Session session2 =
repository.login(new CredentialsImpl("admin", "admin".toCharArray()), session.getWorkspace().getName());
try
{
session2.getRootNode().getNode("someNode").update("/");
fail();
}
catch (LockException e)
{
}
finally
{
session2.logout();
someNode.unlock();
}
}
public void testValidateChildNodeWhenNodeIsProtected() throws PathNotFoundException, ItemExistsException,
NoSuchNodeTypeException, LockException, VersionException, ConstraintViolationException, RepositoryException
{
NodeImpl testNode = (NodeImpl)root.addNode("someNode", "exo:myTypeJCR1703").getNode("exo:myChildNode");
try
{
((NodeImpl)root.getNode("someNode")).validateChildNode(testNode.getInternalName(),
((NodeTypeImpl)testNode.getPrimaryNodeType()).getQName());
fail();
}
catch (ConstraintViolationException e)
{
}
}
public void testVersionHistoryWhenNodeHaventVersionHistory() throws ItemExistsException, PathNotFoundException,
VersionException, ConstraintViolationException, LockException, RepositoryException
{
NodeImpl testNode = (NodeImpl)root.addNode("someNode");
try
{
testNode.versionHistory(false);
fail();
}
catch (UnsupportedRepositoryOperationException e)
{
}
}
public void testRemoveMixinWhenRemovedLockableMixin() throws ItemExistsException, PathNotFoundException,
VersionException,
ConstraintViolationException, LockException, RepositoryException
{
Node someNode = root.addNode("someNode");
someNode.addMixin("mix:lockable");
session.save();
someNode.lock(true, false);
Session session2 =
repository.login(new CredentialsImpl("admin", "admin".toCharArray()), session.getWorkspace().getName());
try
{
session2.getRootNode().getNode("someNode").removeMixin("mix:lockable");
fail();
}
catch (LockException e)
{
}
finally
{
session2.logout();
someNode.unlock();
}
}
}