@Before public void setup() { NodeBuilder rootBuilder = EmptyNodeState.EMPTY_NODE.builder(); NodeBuilder test = rootBuilder.child("test"); test.setProperty("a", 1); test.setProperty("b", 2); test.setProperty("c", 3); test.child("x"); test.child("y"); test.child("z").child("zz"); root = rootBuilder.getNodeState(); }
@Override public boolean childNodeDeleted(String name, NodeState before) { if (!builder.hasChildNode(name)) { deleteDeletedNode(builder, name, before); } else if (before.equals(builder.child(name).getNodeState())) { builder.getChildNode(name).remove(); } else { deleteChangedNode(builder, name, before); } return true; }
@Override public void leave(NodeState before, NodeState after) { if (glob != null && isACE.apply(after) && !builder.hasChildNode(REP_RESTRICTIONS)) { NodeBuilder restrictions = builder.setChildNode(REP_RESTRICTIONS); restrictions.setProperty(JCR_PRIMARYTYPE, NT_REP_RESTRICTIONS, NAME); restrictions.setProperty(glob); builder.removeProperty(REP_GLOB); } }
public static NodeBuilder getOrCreateOakIndex(NodeBuilder root) { NodeBuilder index; if (!root.hasChildNode(INDEX_DEFINITIONS_NAME)) { index = root.child(INDEX_DEFINITIONS_NAME); // TODO: use property node type name index.setProperty(JCR_PRIMARYTYPE, NT_UNSTRUCTURED, NAME); } else { index = root.child(INDEX_DEFINITIONS_NAME); } return index; }
@Override public boolean childNodeDeleted(String name, NodeState before) { builder.getChildNode(name).remove(); return true; }
private void updateEntries(NodeBuilder parent, List<AcEntry> list) { // remove old entries for (String childName : parent.getChildNodeNames()) { if (childName.charAt(0) != 'c') { parent.getChildNode(childName).remove(); } } for (AcEntry ace: list) { ace.writeToPermissionStore(parent); } }
@Test public void move() { NodeBuilder test = store.getRoot().builder().getChildNode("test"); NodeBuilder x = test.getChildNode("x"); NodeBuilder y = test.getChildNode("y"); assertTrue(x.moveTo(y, "xx")); assertFalse(x.exists()); assertTrue(y.exists()); assertFalse(test.hasChildNode("x")); assertTrue(y.hasChildNode("xx")); }
@Test public void testReplacedStatus2() { NodeBuilder x = base.builder().getChildNode("x"); NodeBuilder q = x.getChildNode("q"); q.remove(); assertFalse(q.isReplaced()); x.setChildNode("q").setProperty("a", "b"); assertTrue(q.isReplaced()); }
@Test public void addNode() { NodeBuilder builder = before.builder(); builder.getChildNode("m").getChildNode("n").setChildNode("new").setProperty("p", "3"); nodeObserver.contentChanged(builder.getNodeState(), CommitInfo.EMPTY); assertEquals(ImmutableMap.of("/m/n/new", ImmutableSet.of("p")), nodeObserver.added); assertTrue(nodeObserver.deleted.isEmpty()); assertTrue(nodeObserver.changed.isEmpty()); assertTrue(nodeObserver.properties.isEmpty()); }
private static void removeChild(NodeBuilder target, String name) { target.getChildNode(name).remove(); PropertyState childOrder = target.getProperty(TreeConstants.OAK_CHILD_ORDER); if (childOrder != null) { PropertyBuilder<String> builder = PropertyBuilder.copy(NAME, childOrder); builder.removeValue(name); target.setProperty(builder.getPropertyState()); } }
private static void addTestContent(@NotNull String parent, @NotNull NodeStore nodeStore) throws CommitFailedException, IOException { NodeBuilder rootBuilder = nodeStore.getRoot().builder(); NodeBuilder parentBuilder = rootBuilder.child(parent); parentBuilder.setChildNode("a").setChildNode("aa").setProperty("p", 42); parentBuilder.getChildNode("a").setChildNode("bb").setChildNode("bbb"); parentBuilder.setChildNode("b").setProperty("bin", createBlob(nodeStore, 42)); parentBuilder.setChildNode("c").setProperty(binaryPropertyFromBlob("bins", createBlobs(nodeStore, 42, 43, 44))); nodeStore.merge(rootBuilder, EmptyHook.INSTANCE, CommitInfo.EMPTY); }
@Test public void testRemovedStatus() { NodeBuilder root = base.builder(); NodeBuilder x = root.child("x"); root.getChildNode("x").remove(); assertFalse(x.exists()); assertFalse(x.isNew()); assertFalse(x.isModified()); }
@Test public void testRemovedNodesAreModified() { NodeBuilder builder = base.builder(); builder.getChildNode("a").remove(); builder.getChildNode("c").getChildNode("d").remove(); Set<String> paths = ModifiedPathDiff.getModifiedPaths(base, builder.getNodeState()); assertEquals(newHashSet("/a", "/c/d"), paths); }
private void markCurrentIndexFilesUnsafeForActiveDeletionFor(NodeBuilder rootBuilder, String indexPath) { NodeBuilder indexPathBuilder = getBuilderForPath(rootBuilder, indexPath); if (!TYPE_LUCENE.equals(indexPathBuilder.getProperty(TYPE_PROPERTY_NAME).getValue(STRING))) { LOG.debug("Ignoring index {} as it's not a lucene index", indexPath); return; } NodeBuilder dataNodeBuilder = indexPathBuilder.getChildNode(INDEX_DATA_CHILD_NAME); for (String indexFileName : dataNodeBuilder.getChildNodeNames()) { NodeBuilder indexFileBuilder = dataNodeBuilder.getChildNode(indexFileName); indexFileBuilder.setProperty(PROP_UNSAFE_FOR_ACTIVE_DELETION, true); } }
@Test public void setNodeTest() { NodeBuilder rootBuilder = EMPTY_NODE.builder(); // +"/a":{"c":{"c"="cValue"}} rootBuilder.setChildNode("a", createBC(true)); NodeState c = rootBuilder.getNodeState().getChildNode("a").getChildNode("c"); assertTrue(c.hasProperty("c")); rootBuilder.child("a").child("c").setProperty("c2", "c2Value"); c = rootBuilder.getNodeState().getChildNode("a").getChildNode("c"); assertTrue(c.hasProperty("c")); assertTrue(c.hasProperty("c2")); }
private static void modifyTestContent(NodeStore nodeStore) throws CommitFailedException { NodeBuilder builder = nodeStore.getRoot().builder(); builder.getChildNode("a").getChildNode("aa").remove(); builder.getChildNode("b").setProperty("bin", "changed"); builder.getChildNode("c").removeProperty("bins"); nodeStore.merge(builder, EmptyHook.INSTANCE, CommitInfo.EMPTY); }
private static void removeMixin(NodeBuilder builder, String name) { if (builder.hasProperty(JCR_MIXINTYPES)) { final Set<String> mixins = newHashSet(builder.getProperty(JCR_MIXINTYPES).getValue(Type.NAMES)); if (mixins.remove(name)) { if (mixins.isEmpty()) { builder.removeProperty(JCR_MIXINTYPES); } else { builder.setProperty(nameProperty(JCR_MIXINTYPES, mixins)); } } } }
@Test public void testConnectOnUpdateProperty() { NodeBuilder root = base.builder(); NodeBuilder childA = root.child("x"); NodeBuilder childB = root.child("x"); childB.setProperty("test", "foo"); childA.setProperty("test", "bar"); assertEquals("bar", childA.getProperty("test").getValue(STRING)); assertEquals("bar", childB.getProperty("test").getValue(STRING)); }
private NodeState corruptIndex(String indexPath) { NodeBuilder dir = TestUtil.child(builder, PathUtils.concat(indexPath, ":data")); for (String name : dir.getChildNodeNames()){ if (!"segments.gen".equals(name)){ dir.getChildNode(name).setProperty(PropertyStates.createProperty("jcr:data", Collections .singletonList(new ArrayBasedBlob("foo".getBytes())), Type.BINARIES)); } } TestUtil.child(builder, PathUtils.concat(indexPath, IndexDefinition.STATUS_NODE)).setProperty("foo", "bar"); return builder.getNodeState(); }
@Test public void isReplacedBehaviour() throws Exception{ NodeBuilder nb = store.getRoot().builder(); nb.child("a").setProperty("foo", "bar"); store.merge(nb, EmptyHook.INSTANCE, CommitInfo.EMPTY); nb = store.getRoot().builder(); nb.child("a").child("b"); assertFalse(nb.getChildNode("a").isReplaced("foo")); }