@Test @FixFor("MODE-1401") public void shouldAllowRemovingFromCheckedInNodeExistingChildNodeWithOpvOfIgnore() throws Exception { registerNodeTypes(session, "cnd/versioning.cnd"); // Set up parent node and check it in ... Node parent = session.getRootNode().addNode("versionableNode", "ver:versionable"); parent.setProperty("versionProp", "v"); parent.setProperty("copyProp", "c"); parent.setProperty("ignoreProp", "i"); Node child1 = parent.addNode("nonVersionedIgnoredChild", "ver:nonVersionableChild"); child1.setProperty("copyProp", "c"); child1.setProperty("ignoreProp", "i"); Node child2 = parent.addNode("versionedIgnoredChild", "ver:versionableChild"); child2.setProperty("copyProp", "c"); child2.setProperty("ignoreProp", "i"); session.save(); versionManager.checkin(parent.getPath()); // Should be able to change the properties on the ignored children child1.setProperty("copyProp", "c2"); child1.setProperty("ignoreProp", "i2"); child2.setProperty("copyProp", "c2"); child2.setProperty("ignoreProp", "i2"); session.save(); // Try to remove the two child nodes that have an OPV of 'ignore' ... child1.remove(); child2.remove(); session.save(); // Should be able to change the ignored properties on the checked-in parent ... parent.setProperty("ignoreProp", "i"); // Should not be able to set any non-ignored properties on the checked in parent ... try { parent.setProperty("copyProp", "c2"); fail("not allowed"); } catch (VersionException e) { // expected } try { parent.setProperty("versionProp", "v2"); fail("not allowed"); } catch (VersionException e) { // expected } }
/** * Remove the specified node from the workspace * * @param nodePath the path of the node to be removed * @throws EcmException if any error occurred */ public void removeNode(String nodePath) throws EcmException { Node node = null; /** Load the node */ node = this.getNode(nodePath); /** Validate if the node is exist or not */ this.validateNodeInstance(node); try { node.remove(); this.session.save(); } catch (AccessDeniedException e) { throw new EcmException("Fail to remove node.", e, ErrorCodes.REPOSITROY_ERR_ACCESS_DENIED); } catch (VersionException e) { throw new EcmException("Fail to remove node.", e, ErrorCodes.REPOSITROY_ERR_VERSION_ERROR); } catch (LockException e) { throw new EcmException("Fail to remove node.", e, ErrorCodes.REPOSITROY_ERR_VERSION_ERROR); } catch (ConstraintViolationException e) { throw new EcmException( "Fail to remove node.", e, ErrorCodes.REPOSITROY_ERR_CONSTRAINT_VIOLATION); } catch (RepositoryException e) { throw new EcmException("Fail to remove node.", e, ErrorCodes.REPOSITROY_ERR_GENERIC); } }
/** * Test if mode <i>sync</i> is putting a binary only present in /var/dam into the workflow as * indicated by <i>wfModelId</i>. * * @throws Exception in case of any error */ public void testAssetSync() throws Exception { Node aNode = getAsset(false).adaptTo(Node.class); aNode.remove(); aNode.getSession().save(); executeWorkflowProcess(getTiff().getParent().getPath(), "mode:sync,wfModelId:" + WORKFLOW_ID); checkCreated(getTiff().getPath()); }
private boolean removeNode(String path) { Resource templateResource = resourceResolver.getResource(path); if (templateResource != null) { Node nodeToDelete = templateResource.adaptTo(Node.class); if (nodeToDelete != null) { try { nodeToDelete.remove(); TemplateUtils.saveNode(nodeToDelete); session.save(); return true; } catch (VersionException ex) { java.util.logging.Logger.getLogger(TemplateManagerDeleteServlet.class.getName()) .log(Level.SEVERE, null, ex); } catch (LockException ex) { java.util.logging.Logger.getLogger(TemplateManagerDeleteServlet.class.getName()) .log(Level.SEVERE, null, ex); } catch (ConstraintViolationException ex) { java.util.logging.Logger.getLogger(TemplateManagerDeleteServlet.class.getName()) .log(Level.SEVERE, null, ex); } catch (AccessDeniedException ex) { java.util.logging.Logger.getLogger(TemplateManagerDeleteServlet.class.getName()) .log(Level.SEVERE, null, ex); } catch (RepositoryException ex) { java.util.logging.Logger.getLogger(TemplateManagerDeleteServlet.class.getName()) .log(Level.SEVERE, null, ex); } finally { session.logout(); } } } return false; }
@Test @FixFor("MODE-1976") public void shouldCopyFromFederatedSourceToNonFederatedTargetSameWs() throws Exception { federationManager.createProjection( "/testRoot", SOURCE_NAME, MockConnector.DOC1_LOCATION, "fed1"); Node federated1 = jcrSession().getNode("/testRoot/fed1").addNode("federated1"); federated1.setProperty("prop", "value"); jcrSession().getRootNode().addNode("testRoot2"); jcrSession().save(); jcrSession().getWorkspace().copy("/testRoot/fed1", "/testRoot2/fed1"); assertNodeFound("/testRoot2/fed1"); Node federated1Copy = assertNodeFound("/testRoot2/fed1/federated1"); federated1Copy.remove(); jcrSession().save(); assertNodeFound("/testRoot/fed1/federated1"); jcrSession().getRootNode().addNode("testRoot3"); jcrSession().save(); jcrSession().getWorkspace().copy("/testRoot/fed1/federated1", "/testRoot3"); federated1Copy = assertNodeFound("/testRoot3[2]"); assertNotNull(federated1Copy.getProperty("prop")); }
@Override public void deleteDirectory(long companyId, long repositoryId, String dirName) throws PortalException { Session session = null; try { session = JCRFactoryUtil.createSession(); Node rootNode = getRootNode(session, companyId); Node repositoryNode = getFolderNode(rootNode, repositoryId); Node dirNode = repositoryNode.getNode(dirName); dirNode.remove(); session.save(); } catch (PathNotFoundException pnfe) { throw new NoSuchDirectoryException(dirName); } catch (RepositoryException re) { String message = GetterUtil.getString(re.getMessage()); if (message.contains("failed to resolve path")) { throw new NoSuchDirectoryException(dirName); } else { throw new PortalException(re); } } finally { JCRFactoryUtil.closeSession(session); } }
public void testRestoreSNS() throws RepositoryException { Session session = getHelper().getSuperuserSession(); // - Create a node 'a' with nodetype nt:unstructured // (defining it's childnodes to show OPV Version behaviour) Node node = session.getRootNode().addNode("RestoreSameNameSiblingTest"); try { // - Create a child node 'b' node.addNode("test"); // - Make 'a' versionable (add mixin mix:versionable) node.addMixin(mixVersionable); session.save(); // - Checkin/Checkout 'a' Version version = node.checkin(); node.checkout(); assertEquals(1, node.getNodes("test").getSize()); // - Restore any version of 'a' node.restore(version, true); assertEquals(1, node.getNodes("test").getSize()); } finally { node.remove(); session.save(); session.logout(); } }
@Test public void removingInternalNodeShouldNotRemoveExternalNodes() throws Exception { federationManager.createProjection( "/testRoot", SOURCE_NAME, MockConnector.DOC2_LOCATION, "federated2"); Node internalNode1 = testRoot.addNode("internalNode1"); session.save(); federationManager.createProjection( "/testRoot/internalNode1", SOURCE_NAME, MockConnector.DOC2_LOCATION, "federated2"); // remove the federated node directly assertNodeFound("/testRoot/internalNode1/federated2/federated3"); internalNode1.remove(); session.save(); // check external nodes are still there assertNodeFound("/testRoot/federated2/federated3"); testRoot.addNode("internalNode2").addNode("internalNode2_1"); session.save(); federationManager.createProjection( "/testRoot/internalNode2/internalNode2_1", SOURCE_NAME, MockConnector.DOC2_LOCATION, "federated2"); // remove an ancestor of the federated node assertNodeFound("/testRoot/internalNode2/internalNode2_1/federated2/federated3"); ((Node) session.getNode("/testRoot/internalNode2")).remove(); session.save(); // check external nodes are still there assertNodeFound("/testRoot/federated2/federated3"); }
/** * test method addFavourite. Input: /testAddFavourite node tested action: add favorite for 3 users * 'root', 'demo', 'james' to the node above. Expected value : 1 for favorite node list size of * each user /testAddFavourite node) * * @throws Exception */ public void testAddFavorite() throws Exception { Node rootNode = session.getRootNode(); Node testAddFavouriteNode = rootNode.addNode("testAddFavorite"); session.save(); favoriteService.addFavorite(testAddFavouriteNode, "root"); favoriteService.addFavorite(testAddFavouriteNode, "demo"); favoriteService.addFavorite(testAddFavouriteNode, "james"); int rootFav = favoriteService .getAllFavoriteNodesByUser(session.getWorkspace().getName(), REPO_NAME, "root") .size(); int demoFav = favoriteService .getAllFavoriteNodesByUser(session.getWorkspace().getName(), REPO_NAME, "demo") .size(); int jamesFav = favoriteService .getAllFavoriteNodesByUser(session.getWorkspace().getName(), REPO_NAME, "james") .size(); assertEquals("testAddFavorite failed!", 1, rootFav); assertEquals("testAddFavorite failed!", 1, demoFav); assertEquals("testAddFavorite failed!", 1, jamesFav); testAddFavouriteNode.remove(); session.save(); }
/** * test method getAllFavouriteNodesByUser. Input: /node0 /node1 /node2 /node3 /node3/node4. Tested * action: add favorite for 'root' to node0, node2, node4; add favorite for 'demo' to property of * node1, * * <p>expectedValue : 4 ( number of favorite nodes by 'root') * * @throws Exception */ public void testGetAllFavouriteNodesByUser() throws Exception { Node rootNode = session.getRootNode(); Node testNode = rootNode.addNode("testNode"); session.save(); Node node0 = testNode.addNode("node0"); Node node1 = testNode.addNode("node1"); Node node2 = testNode.addNode("node2"); Node node3 = testNode.addNode("node3"); Node node4 = node3.addNode("node4"); favoriteService.addFavorite(node0, "root"); favoriteService.addFavorite(node1, "demo"); favoriteService.addFavorite(node2, "root"); favoriteService.addFavorite(node3, "root"); favoriteService.addFavorite(node4, "root"); assertEquals( "testGetAllFavouriteNodesByUser failed!", 4, favoriteService .getAllFavoriteNodesByUser( rootNode.getSession().getWorkspace().getName(), "repository", "root") .size()); testNode.remove(); session.save(); }
@Test /** * Name of a versioned node is available in the parent history. Translator takes care of this when * hippo:paths is present on the node, with the parent as one of its values. */ public void testVersionedNode() throws Exception { Node parent = session.getRootNode().addNode("test", "nt:unstructured"); parent.addMixin("mix:versionable"); Node child = parent.addNode("child", "nt:unstructured"); child.addMixin("mix:versionable"); child.setProperty("hippo:paths", new String[] {child.getUUID(), parent.getUUID()}); session.save(); child.checkin(); parent.checkin(); VersionHistory vh = child.getVersionHistory(); parent.checkout(); child.remove(); session.save(); parent.checkin(); VersionIterator versionIter = vh.getAllVersions(); versionIter.nextVersion(); // ignore root Version version = versionIter.nextVersion(); NodeTranslator nt = new NodeTranslator(new JcrNodeModel(version.getNode("jcr:frozenNode"))); assertEquals("child", nt.getNodeName().getObject()); assertTrue(version.getNode("jcr:frozenNode").isNodeType("mix:referenceable")); }
@Override protected void tearDown() throws Exception { testRoot.remove(); root.save(); super.tearDown(); }
/** * Tests if a node moved triggers the correct events when the former parent node is removed at the * same time. */ public void testMoveWithRemove() throws RepositoryException { /** * Initial tree: + testroot + nodename1 + nodename2 + nodename3 * * <p>After move and remove: + testroot + nodename3 + nodename2 */ Node n1 = testRootNode.addNode(nodeName1, testNodeType); Node n2 = n1.addNode(nodeName2, testNodeType); Node n3 = testRootNode.addNode(nodeName3, testNodeType); testRootNode.save(); EventResult addNodeListener = new EventResult(log); EventResult removeNodeListener = new EventResult(log); EventResult moveNodeListener = new EventResult(log); addEventListener(addNodeListener, Event.NODE_ADDED); addEventListener(removeNodeListener, Event.NODE_REMOVED); addEventListener(moveNodeListener, Event.NODE_MOVED); // move n2 superuser.move(n2.getPath(), n3.getPath() + "/" + nodeName2); // remove n1 n1.remove(); testRootNode.save(); Event[] added = addNodeListener.getEvents(DEFAULT_WAIT_TIMEOUT); Event[] removed = removeNodeListener.getEvents(DEFAULT_WAIT_TIMEOUT); Event[] moved = moveNodeListener.getEvents(DEFAULT_WAIT_TIMEOUT); removeEventListener(addNodeListener); removeEventListener(removeNodeListener); removeEventListener(moveNodeListener); checkNodeAdded(added, new String[] {nodeName3 + "/" + nodeName2}, null); checkNodeRemoved(removed, new String[] {nodeName1 + "/" + nodeName2, nodeName1}, null); checkNodeMoved(moved, nodeName1 + "/" + nodeName2, nodeName3 + "/" + nodeName2); }
/** {@inheritDoc} */ public void removeTemplate( String portletName, String category, String templateName, SessionProvider sessionProvider) throws Exception { Node templateNode = getTemplateByName(portletName, category, templateName, sessionProvider); Session session = templateNode.getSession(); templateNode.remove(); session.save(); }
@Override @After public void tearDown() throws Exception { super.tearDown(); baseFolder.remove(); session.save(); }
public void afterSuite() throws Exception { for (int i = 0; i < NODE_COUNT; i++) { root.getNode("node" + i).remove(); session.save(); } root.remove(); session.save(); }
@Test @FixFor("MODE-1751") public void shouldNotCauseReferentialIntegrityExceptionWhenSameReferrerUpdatedMultipleTimes() throws Exception { Node nodeA = session.getRootNode().addNode("nodeA"); nodeA.addMixin("mix:referenceable"); Node nodeB = session.getRootNode().addNode("nodeB"); nodeB.setProperty("nodeA", session.getValueFactory().createValue(nodeA, false)); session.save(); nodeB.setProperty("nodeA", session.getValueFactory().createValue(nodeA, false)); session.save(); nodeB.remove(); session.save(); nodeA.remove(); session.save(); }
public void removeAttachment(Node documentNode, String language) throws RepositoryException { String lang = language; if (lang == null) { lang = I18NHelper.defaultLanguage; } if (documentNode.hasNode(SimpleDocument.FILE_PREFIX + lang)) { Node attachmentNode = documentNode.getNode(SimpleDocument.FILE_PREFIX + lang); attachmentNode.remove(); } }
@Override public void removeNode(String path) throws RemoteException { try { Node node = (Node) session().getItem(path); node.remove(); } catch (PathNotFoundException e) { log.log(Level.FINER, e.getLocalizedMessage()); } catch (RepositoryException e) { throw new RemoteException(e.getMessage()); } }
/** * Given the relative path of a comment, delete the index for that comment. * * @param relPath the relative path of the comment. */ public void delete(final String relPath, final ResourceResolver resolver) throws RepositoryException { final Resource folder = resolver.getResource(path + relPath); if (folder == null) { return; } final Node folderNode = folder.adaptTo(Node.class); folderNode.remove(); }
@Override public void afterEach() throws Exception { NodeIterator nodeIterator = session.getRootNode().getNodes(); while (nodeIterator.hasNext()) { Node node = nodeIterator.nextNode(); if (!JcrLexicon.SYSTEM.getString().equals(node.getName())) { node.remove(); } } session.save(); super.afterEach(); }
private Node prepNode(ResourceResolver resolver, String path) throws RepositoryException { // Get the encoding node, remove it (as a way to easily remove all the existing presets), then // create the node again // Session session = resolver.adaptTo(Session.class); Node targetNode = JcrResourceUtil.createPath(path, "nt:unstructured", "nt:unstructured", session, false); Node parent = targetNode.getParent(); String nodeName = targetNode.getName(); targetNode.remove(); return parent.addNode(nodeName); }
/** * Test if in mode <i>sync</i>, if it prevents to remove a binary if this binary is currently a * payload in Workflow * * @throws Exception in case of any error */ public void testSkipSameWorkflowFolder() throws Exception { Node aNode = getAsset(false).adaptTo(Node.class); aNode.remove(); aNode.getSession().save(); startWorkflow(WORKFLOW_ID, getTiff().getPath()); executeWorkflowProcess(getTiff().getParent().getPath(), "mode:sync,wfModelId:" + WORKFLOW_ID); // thats a little wrong, as the wf was not startate by the process but // by this test. still one workflow for the payload witht the id must // exist checkCreated(getTiff().getPath()); }
/** delete all of book in workspace */ public void deleteAll() { SessionProvider sProvider = SessionProvider.createSystemProvider(); try { Node parentNode = getNodeByPath(DEFAULT_PARENT_PATH, sProvider); parentNode.remove(); parentNode.getSession().save(); } catch (RepositoryException e) { log.error("Failed to delete all book", e); } finally { sProvider.close(); } }
/** * delete a book by book id * * @param id The id of book * @throws BookNotFoundException */ public void deleteBook(String id) throws BookNotFoundException { SessionProvider sProvider = SessionProvider.createSystemProvider(); try { Node node = getNodeByPath(DEFAULT_PARENT_PATH + "/" + id, sProvider); node.remove(); node.getSession().save(); } catch (RepositoryException re) { log.error("Failed to delete book by id", re); } finally { sProvider.close(); } }
@Test public void shouldHavePath() throws Exception { assertThat(altima.getPath(), is("/Cars/Hybrid/Nissan Altima")); javax.jcr.Node altima2 = hybrid.addNode("Nissan Altima"); try { assertThat(altima2, is(notNullValue())); assertThat(altima2.getPath(), is("/Cars/Hybrid/Nissan Altima[2]")); } finally { altima2.remove(); // remove the node we added in this test to not interfere with other tests } }
@Test public void shouldHaveSameNameSiblingIndex() throws Exception { assertThat(altima.getIndex(), is(1)); javax.jcr.Node altima2 = hybrid.addNode("Nissan Altima"); try { assertThat(altima2, is(notNullValue())); assertThat(altima2.getIndex(), is(2)); } finally { altima2.remove(); // remove the node we added in this test to not interfere with other tests } }
/** * Deletes the subgraph at the node with the specified id, including all descendants. * * @param request the servlet request; may not be null or unauthenticated * @param rawRepositoryName the URL-encoded repository name * @param rawWorkspaceName the URL-encoded workspace name * @param id the node identifier * @throws NotFoundException if no item exists at {@code path} * @throws javax.ws.rs.NotAuthorizedException if the user does not have the access required to * delete the node with this id. * @throws RepositoryException if any other error occurs */ public void deleteNodeWithId( HttpServletRequest request, String rawRepositoryName, String rawWorkspaceName, String id) throws NotFoundException, NotAuthorizedException, RepositoryException { assert rawRepositoryName != null; assert rawWorkspaceName != null; assert id != null; Session session = getSession(request, rawRepositoryName, rawWorkspaceName); Node node = nodeWithId(id, session); node.remove(); session.save(); }
/** * {@inheritDoc} * * @see * org.modeshape.graph.request.processor.RequestProcessor#process(org.modeshape.graph.request.DeleteBranchRequest) */ @Override public void process(DeleteBranchRequest request) { if (request == null) return; try { Workspace workspace = workspaceFor(request.inWorkspace()); Node node = workspace.node(request.at()); Location actual = workspace.locationFor(node); node.remove(); request.setActualLocationOfNode(actual); } catch (Throwable e) { request.setError(e); } }
@Test public void removingProjectionViaNodeRemoveShouldDeleteExternalNodes() throws Exception { federationManager.createProjection( "/testRoot", SOURCE_NAME, MockConnector.DOC2_LOCATION, "projection1"); federationManager.createProjection( "/testRoot", SOURCE_NAME, MockConnector.DOC2_LOCATION, "projection2"); Node projection1 = assertNodeFound("/testRoot/projection1/federated3"); assertNodeFound("/testRoot/projection2/federated3"); projection1.remove(); session.save(); assertNodeNotFound("/testRoot/projection2/federated3"); }