Java tutorial
/** * This file Copyright (c) 2003-2012 Magnolia International * Ltd. (http://www.magnolia-cms.com). All rights reserved. * * * This file is dual-licensed under both the Magnolia * Network Agreement and the GNU General Public License. * You may elect to use one or the other of these licenses. * * This file is distributed in the hope that it will be * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the * implied warranty of MERCHANTABILITY or FITNESS FOR A * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT. * Redistribution, except as permitted by whichever of the GPL * or MNA you select, is prohibited. * * 1. For the GPL license (GPL), you can redistribute and/or * modify this file under the terms of the GNU General * Public License, Version 3, as published by the Free Software * Foundation. You should have received a copy of the GNU * General Public License, Version 3 along with this program; * if not, write to the Free Software Foundation, Inc., 51 * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * 2. For the Magnolia Network Agreement (MNA), this file * and the accompanying materials are made available under the * terms of the MNA which accompanies this distribution, and * is available at http://www.magnolia-cms.com/mna.html * * Any modifications to this file must keep this entire header * intact. * */ package info.magnolia.cms.util; import static info.magnolia.nodebuilder.Ops.addNode; import static java.util.Arrays.asList; import static org.easymock.EasyMock.*; import static org.junit.Assert.*; import info.magnolia.cms.core.Content; import info.magnolia.cms.core.DefaultContent; import info.magnolia.cms.core.HierarchyManager; import info.magnolia.cms.core.ItemType; import info.magnolia.nodebuilder.NodeBuilder; import info.magnolia.test.MgnlTestCase; import info.magnolia.test.mock.MockContent; import info.magnolia.test.mock.MockHierarchyManager; import info.magnolia.test.mock.MockUtil; import info.magnolia.test.mock.jcr.MockNode; import info.magnolia.test.mock.jcr.MockSession; import info.magnolia.test.mock.jcr.SessionTestUtil; import java.io.IOException; import java.util.Arrays; import java.util.Collection; import java.util.List; import javax.jcr.Node; import javax.jcr.RepositoryException; import org.apache.commons.collections.CollectionUtils; import org.apache.commons.collections.Transformer; import org.junit.Before; import org.junit.Test; /** * Tests for {@link ContentUtil} which do rely on an actual repository, i.e not using {@link info.magnolia.test.RepositoryTestCase}. * * @version $Id$ */ public class ContentUtilTest extends MgnlTestCase { private MockContent rootABC; @Override @Before public void setUp() { rootABC = new MockContent(MockNode.ROOT_NODE_NAME, ItemType.CONTENT); new NodeBuilder(rootABC, addNode("a", ItemType.CONTENT).then(addNode("aa", ItemType.CONTENT), addNode("ab", ItemType.CONTENTNODE).then(addNode("abb", ItemType.CONTENTNODE))), addNode("b", ItemType.CONTENT), addNode("c", ItemType.CONTENTNODE)).exec(); } @Test public void testVisitShouldPassFilterAlong() throws Exception { final ItemType foo = new ItemType("foo"); final ItemType bar = new ItemType("bar"); final MockContent root = new MockContent(MockNode.ROOT_NODE_NAME, foo); final MockContent child1 = new MockContent("child1", foo); root.addContent(child1); final MockContent child2 = new MockContent("child2", bar); root.addContent(child2); final MockContent child2child = new MockContent("child2-child", foo); child2.addContent(child2child); final MockContent child3 = new MockContent("child3", foo); root.addContent(child3); final MockContent child3childFoo = new MockContent("child3-childFoo", foo); child3.addContent(child3childFoo); final MockContent child3childFoo2 = new MockContent("child3-childFoo2", foo); child3.addContent(child3childFoo2); final MockContent child3childFooChild = new MockContent("child3-childFoo-child", foo); child3childFoo.addContent(child3childFooChild); final MockContent child3childBar = new MockContent("child3-childBar", bar); child3.addContent(child3childBar); final MockContent child4 = new MockContent("child4", bar); root.addContent(child4); final MockContent child5 = new MockContent("child5", foo); root.addContent(child5); final ContentTypeRejector filter = new ContentTypeRejector("bar"); final ContentUtil.Visitor visitor = createStrictMock(ContentUtil.Visitor.class); visitor.visit(root); visitor.visit(child1); visitor.visit(child3); visitor.visit(child3childFoo); visitor.visit(child3childFooChild); visitor.visit(child3childFoo2); visitor.visit(child5); replay(visitor); ContentUtil.visit(root, visitor, filter); verify(visitor); } @Test public void testDeleteAndRemoveParentsIfAnOtherChild() throws IOException, RepositoryException { String content = "/node1/child1\n" + "/node1/child2\n"; HierarchyManager hm = MockUtil.createHierarchyManager(content); Content child1 = hm.getContent("/node1/child1"); ContentUtil.deleteAndRemoveEmptyParents(child1); assertTrue("node1 should not be deleted because it has children", hm.isExist("/node1")); } @Test public void testDeleteAndRemoveParentsIfNoOtherChild() throws IOException, RepositoryException { String content = "/node1/child1"; HierarchyManager hm = MockUtil.createHierarchyManager(content); Content child1 = hm.getContent("/node1/child1"); ContentUtil.deleteAndRemoveEmptyParents(child1); assertTrue("node1 must be deleted because it has no children", !hm.isExist("/node1")); } @Test public void testDeleteAndRemoveParentsWithLevel() throws IOException, RepositoryException { String content = "/node1/child1/subchild1"; HierarchyManager hm = MockUtil.createHierarchyManager(content); Content subchild1 = hm.getContent("/node1/child1/subchild1"); ContentUtil.deleteAndRemoveEmptyParents(subchild1, 1); assertTrue("child1 must be deleted because it has no children", !hm.isExist("/node1/child1")); assertTrue("node1 must existe because the level was defined", hm.isExist("/node1")); } @Test public void testOrderAfter() throws RepositoryException, IOException { MockHierarchyManager hm = MockUtil.createHierarchyManager("/node/a\n" + "/node/b\n" + "/node/c\n"); Content node = hm.getContent("/node"); Content a = node.getContent("a"); ContentUtil.orderAfter(a, "b"); Collection<Content> result = node.getChildren(); CollectionUtils.transform(result, new Transformer() { @Override public Object transform(Object childObj) { return ((Content) childObj).getName(); } }); assertEquals(Arrays.asList(new String[] { "b", "a", "c" }), result); } @Test public void testOrderAfterLastNode() throws RepositoryException, IOException { MockHierarchyManager hm = MockUtil.createHierarchyManager("/node/a\n" + "/node/b\n" + "/node/c\n"); Content node = hm.getContent("/node"); Content a = node.getContent("a"); ContentUtil.orderAfter(a, "c"); Collection<Content> result = node.getChildren(); CollectionUtils.transform(result, new Transformer() { @Override public Object transform(Object childObj) { return ((Content) childObj).getName(); } }); assertEquals(asList("b", "c", "a"), result); } @Test public void testOrderAfterLastNodeVariation1() throws RepositoryException, IOException { MockHierarchyManager hm = MockUtil.createHierarchyManager( "/node/a\n" + "/node/b\n" + "/node/c\n" + "/node/d\n" + "/node/e\n" + "/node/f\n"); Content node = hm.getContent("/node"); Content a = node.getContent("c"); ContentUtil.orderAfter(a, "f"); Collection<Content> result = node.getChildren(); CollectionUtils.transform(result, new Transformer() { @Override public Object transform(Object childObj) { return ((Content) childObj).getName(); } }); assertEquals(asList("a", "b", "d", "e", "f", "c"), result); } @Test public void testOrderAfterFirstNodeOnlyThree() throws RepositoryException, IOException { MockHierarchyManager hm = MockUtil.createHierarchyManager("/node/a\n" + "/node/b\n" + "/node/c\n"); Content node = hm.getContent("/node"); Content c = node.getContent("c"); ContentUtil.orderAfter(c, "a"); Collection<Content> result = node.getChildren(); CollectionUtils.transform(result, new Transformer() { @Override public Object transform(Object childObj) { return ((Content) childObj).getName(); } }); assertEquals(asList("a", "c", "b"), result); } @Test public void testOrderAfterFirstNodeMoreThanThreeVariation1() throws RepositoryException, IOException { MockHierarchyManager hm = MockUtil.createHierarchyManager( "/node/a\n" + "/node/b\n" + "/node/c\n" + "/node/d\n" + "/node/e\n" + "/node/f\n"); Content node = hm.getContent("/node"); Content c = node.getContent("f"); ContentUtil.orderAfter(c, "a"); Collection<Content> result = node.getChildren(); CollectionUtils.transform(result, new Transformer() { @Override public Object transform(Object childObj) { return ((Content) childObj).getName(); } }); assertEquals(asList("a", "f", "b", "c", "d", "e"), result); } @Test public void testOrderAfterFirstNodeMoreThanThreeVariation2() throws RepositoryException, IOException { MockHierarchyManager hm = MockUtil.createHierarchyManager( "/node/a\n" + "/node/b\n" + "/node/c\n" + "/node/d\n" + "/node/e\n" + "/node/f\n"); Content node = hm.getContent("/node"); Content c = node.getContent("e"); ContentUtil.orderAfter(c, "a"); Collection<Content> result = node.getChildren(); CollectionUtils.transform(result, new Transformer() { @Override public Object transform(Object childObj) { return ((Content) childObj).getName(); } }); assertEquals(asList("a", "e", "b", "c", "d", "f"), result); } @Test public void testOrderAfterMidNodeMoreThanThreeVariation1() throws RepositoryException, IOException { MockHierarchyManager hm = MockUtil.createHierarchyManager( "/node/a\n" + "/node/b\n" + "/node/c\n" + "/node/d\n" + "/node/e\n" + "/node/f\n"); Content node = hm.getContent("/node"); Content c = node.getContent("f"); ContentUtil.orderAfter(c, "c"); Collection<Content> result = node.getChildren(); CollectionUtils.transform(result, new Transformer() { @Override public Object transform(Object childObj) { return ((Content) childObj).getName(); } }); assertEquals(asList("a", "b", "c", "f", "d", "e"), result); } @Test public void testOrderAfterMidNodeMoreThanThreeVariation2() throws RepositoryException, IOException { MockHierarchyManager hm = MockUtil.createHierarchyManager( "/node/a\n" + "/node/b\n" + "/node/c\n" + "/node/d\n" + "/node/e\n" + "/node/f\n"); Content node = hm.getContent("/node"); Content c = node.getContent("e"); ContentUtil.orderAfter(c, "b"); Collection<Content> result = node.getChildren(); CollectionUtils.transform(result, new Transformer() { @Override public Object transform(Object childObj) { return ((Content) childObj).getName(); } }); assertEquals(asList("a", "b", "e", "c", "d", "f"), result); } @Test public void testOrderBeforeFirstNodeVariation1() throws RepositoryException, IOException { MockHierarchyManager hm = MockUtil.createHierarchyManager( "/node/a\n" + "/node/b\n" + "/node/c\n" + "/node/d\n" + "/node/e\n" + "/node/f\n"); Content node = hm.getContent("/node"); Content c = node.getContent("c"); ContentUtil.orderBefore(c, "a"); Collection<Content> result = node.getChildren(); CollectionUtils.transform(result, new Transformer() { @Override public Object transform(Object childObj) { return ((Content) childObj).getName(); } }); assertEquals(asList("c", "a", "b", "d", "e", "f"), result); } @Test public void testOrderBeforeFirstNodeVariation2() throws RepositoryException, IOException { MockHierarchyManager hm = MockUtil.createHierarchyManager( "/node/a\n" + "/node/b\n" + "/node/c\n" + "/node/d\n" + "/node/e\n" + "/node/f\n"); Content node = hm.getContent("/node"); Content c = node.getContent("b"); ContentUtil.orderBefore(c, "a"); Collection<Content> result = node.getChildren(); CollectionUtils.transform(result, new Transformer() { @Override public Object transform(Object childObj) { return ((Content) childObj).getName(); } }); assertEquals(asList("b", "a", "c", "d", "e", "f"), result); } @Test public void testOrderBeforeFirstNodeVariation3() throws RepositoryException, IOException { MockHierarchyManager hm = MockUtil.createHierarchyManager( "/node/a\n" + "/node/b\n" + "/node/c\n" + "/node/d\n" + "/node/e\n" + "/node/f\n"); Content node = hm.getContent("/node"); Content c = node.getContent("a"); ContentUtil.orderBefore(c, "b"); Collection<Content> result = node.getChildren(); CollectionUtils.transform(result, new Transformer() { @Override public Object transform(Object childObj) { return ((Content) childObj).getName(); } }); assertEquals(asList("a", "b", "c", "d", "e", "f"), result); } @Test public void testOrderBeforeFirstNodeVariation4() throws RepositoryException, IOException { MockHierarchyManager hm = MockUtil.createHierarchyManager( "/node/a\n" + "/node/b\n" + "/node/c\n" + "/node/d\n" + "/node/e\n" + "/node/f\n"); Content node = hm.getContent("/node"); Content c = node.getContent("f"); ContentUtil.orderBefore(c, "a"); Collection<Content> result = node.getChildren(); CollectionUtils.transform(result, new Transformer() { @Override public Object transform(Object childObj) { return ((Content) childObj).getName(); } }); assertEquals(asList("f", "a", "b", "c", "d", "e"), result); } @Test public void testOrderBeforeLastNodeVariation1() throws RepositoryException, IOException { MockHierarchyManager hm = MockUtil.createHierarchyManager( "/node/a\n" + "/node/b\n" + "/node/c\n" + "/node/d\n" + "/node/e\n" + "/node/f\n"); Content node = hm.getContent("/node"); Content c = node.getContent("a"); ContentUtil.orderBefore(c, "f"); Collection<Content> result = node.getChildren(); CollectionUtils.transform(result, new Transformer() { @Override public Object transform(Object childObj) { return ((Content) childObj).getName(); } }); assertEquals(asList("b", "c", "d", "e", "a", "f"), result); } @Test public void testOrderBeforeLastNodeVariation2() throws RepositoryException, IOException { MockHierarchyManager hm = MockUtil.createHierarchyManager( "/node/a\n" + "/node/b\n" + "/node/c\n" + "/node/d\n" + "/node/e\n" + "/node/f\n"); Content node = hm.getContent("/node"); Content c = node.getContent("c"); ContentUtil.orderBefore(c, "f"); Collection<Content> result = node.getChildren(); CollectionUtils.transform(result, new Transformer() { @Override public Object transform(Object childObj) { return ((Content) childObj).getName(); } }); assertEquals(asList("a", "b", "d", "e", "c", "f"), result); } @Test public void testOrderBeforeLastNodeVariation3() throws RepositoryException, IOException { MockHierarchyManager hm = MockUtil.createHierarchyManager( "/node/a\n" + "/node/b\n" + "/node/c\n" + "/node/d\n" + "/node/e\n" + "/node/f\n"); Content node = hm.getContent("/node"); Content c = node.getContent("e"); ContentUtil.orderBefore(c, "f"); Collection<Content> result = node.getChildren(); CollectionUtils.transform(result, new Transformer() { @Override public Object transform(Object childObj) { return ((Content) childObj).getName(); } }); assertEquals(asList("a", "b", "c", "d", "e", "f"), result); } @Test public void testOrderBeforeMidNodeVariation1() throws RepositoryException, IOException { MockHierarchyManager hm = MockUtil.createHierarchyManager( "/node/a\n" + "/node/b\n" + "/node/c\n" + "/node/d\n" + "/node/e\n" + "/node/f\n"); Content node = hm.getContent("/node"); Content c = node.getContent("b"); ContentUtil.orderBefore(c, "e"); Collection<Content> result = node.getChildren(); CollectionUtils.transform(result, new Transformer() { @Override public Object transform(Object childObj) { return ((Content) childObj).getName(); } }); assertEquals(asList("a", "c", "d", "b", "e", "f"), result); } @Test public void testOrderBeforeMidNodeVariation2() throws RepositoryException, IOException { MockHierarchyManager hm = MockUtil.createHierarchyManager( "/node/a\n" + "/node/b\n" + "/node/c\n" + "/node/d\n" + "/node/e\n" + "/node/f\n"); Content node = hm.getContent("/node"); Content c = node.getContent("a"); ContentUtil.orderBefore(c, "e"); Collection<Content> result = node.getChildren(); CollectionUtils.transform(result, new Transformer() { @Override public Object transform(Object childObj) { return ((Content) childObj).getName(); } }); assertEquals(asList("b", "c", "d", "a", "e", "f"), result); } @Test public void testOrderBeforeMidNodeVariation3() throws RepositoryException, IOException { MockHierarchyManager hm = MockUtil.createHierarchyManager( "/node/a\n" + "/node/b\n" + "/node/c\n" + "/node/d\n" + "/node/e\n" + "/node/f\n"); Content node = hm.getContent("/node"); Content c = node.getContent("f"); ContentUtil.orderBefore(c, "e"); Collection<Content> result = node.getChildren(); CollectionUtils.transform(result, new Transformer() { @Override public Object transform(Object childObj) { return ((Content) childObj).getName(); } }); assertEquals(asList("a", "b", "c", "d", "f", "e"), result); } @Test public void testGetAncestorOfTypeBasicCase() throws RepositoryException { final Content content = rootABC.getContent("a/ab/abb"); assertEquals(rootABC.getContent("a"), ContentUtil.getAncestorOfType(content, ItemType.CONTENT.getSystemName())); } @Test public void testGetAncestorOfTypeReturnsSelfIfMatch() throws RepositoryException { final Content abb = rootABC.getContent("a/ab/abb"); final Content ab = rootABC.getContent("a/ab"); final Content aa = rootABC.getContent("a/aa"); final Content c = rootABC.getContent("c"); assertEquals(abb, ContentUtil.getAncestorOfType(abb, ItemType.CONTENTNODE.getSystemName())); assertEquals(ab, ContentUtil.getAncestorOfType(ab, ItemType.CONTENTNODE.getSystemName())); assertEquals(aa, ContentUtil.getAncestorOfType(aa, ItemType.CONTENT.getSystemName())); assertEquals(c, ContentUtil.getAncestorOfType(c, ItemType.CONTENTNODE.getSystemName())); } @Test public void testGetAncestorOfTypeThrowsExceptionIfNotFound() throws RepositoryException { final Content content = rootABC.getContent("a/aa"); try { ContentUtil.getAncestorOfType(content, ItemType.CONTENTNODE.getSystemName()); fail("should have failed"); } catch (Throwable t) { assertTrue(t instanceof RepositoryException); assertEquals("No ancestor of type mgnl:contentNode found for null:/a/aa[mgnl:content]", t.getMessage()); } } @Test public void testAsContent() throws Exception { // GIVEN MockSession session = SessionTestUtil.createSession("testWorkspace", "/foo/bar/sub1.@uuid=1"); Node node = session.getNode("/foo/bar/sub1"); // WHEN Content content = ContentUtil.asContent(node); // THEN assertEquals(node, content.getJCRNode()); assertTrue(content instanceof DefaultContent); } @Test public void testAsContentReturnsNullIfNodeIsNull() throws Exception { // GIVEN Node node = null; // WHEN Content content = ContentUtil.asContent(node); // THEN assertNull(content); } private final static class ContentTypeRejector implements Content.ContentFilter { private final List<String> rejectedTypes; public ContentTypeRejector(String... rejectedTypes) { this.rejectedTypes = Arrays.asList(rejectedTypes); } @Override public boolean accept(Content content) { try { return !rejectedTypes.contains(content.getNodeTypeName()); } catch (RepositoryException e) { throw new RuntimeException(e); // TODO } } } }