@Override public void leave(NodeState before, NodeState after) throws CommitFailedException { // first check if we have to add anything to paths and/or nodeNames if (changed && level <= support.maxPathDepth) { support.changeSetBuilder.addParentPath(path); } if (changed && childName != null) { support.changeSetBuilder.addParentNodeName(childName); } if (changed){ addParentNodeType(beforeParentNodeOrNull); addParentNodeType(afterParentNodeOrNull); } // then if we're not at the root, we're done if (!isRoot) { return; } // but if we're at the root, then we add the ChangeSet to the // CommitContext of the CommitInfo CommitContext commitContext = (CommitContext) support.info.getInfo().get(CommitContext.NAME); ChangeSet changeSet = support.changeSetBuilder.build(); commitContext.set(ChangeSet.COMMIT_CONTEXT_OBSERVATION_CHANGESET, changeSet); LOG.debug("Collected changeSet for commit {} is {}", support.info, changeSet); }
@Test public void addedChangeSetAlreadyOverflown() throws Exception{ ChangeSetBuilder cb1 = new ChangeSetBuilder(5, 2); add(cb1, "1"); ChangeSet cs1 = new ChangeSet(2, null, of("nn-2"), of("nt-2"), of("pn-2"), of("nt-2")); ChangeSet mcs1 = cb1.add(cs1).build(); assertNull(mcs1.getParentPaths()); assertThat(mcs1.getAllNodeTypes(), containsInAnyOrder("nt-1", "nt-2")); }
@Test public void overflowParentNodeName() throws Exception{ ChangeSetBuilder cb1 = new ChangeSetBuilder(2, 2); add(cb1, "1"); ChangeSet cs1 = new ChangeSet(2, of("p-2"), null, of("pnt-2"), of("pn-2"), of("nt-2")); ChangeSet cs = cb1.add(cs1).build(); assertNull(cs.getParentNodeNames()); assertThat(cs.getAllNodeTypes(), containsInAnyOrder("nt-1", "nt-2")); assertThat(cs.getParentNodeTypes(), containsInAnyOrder("pnt-1", "pnt-2")); assertThat(cs.getPropertyNames(), containsInAnyOrder("pn-1", "pn-2")); ChangeSet cs2 = new ChangeSet(2, of("p-2"), of("nn-2", "nn-3"), of("pnt-2"), of("pn-2"), of("nt-2")); cs = cb1.add(cs2).build(); assertNull(cs.getParentNodeNames()); }
@Test public void overflowPath() throws Exception{ ChangeSetBuilder cb1 = new ChangeSetBuilder(2, 2); add(cb1, "1"); ChangeSet cs1 = new ChangeSet(2, null, of("nn-2"), of("pnt-2"), of("pn-2"), of("nt-2")); ChangeSet cs = cb1.add(cs1).build(); assertNull(cs.getParentPaths()); assertThat(cs.getAllNodeTypes(), containsInAnyOrder("nt-1", "nt-2")); assertThat(cs.getParentNodeNames(), containsInAnyOrder("nn-1", "nn-2")); assertThat(cs.getParentNodeTypes(), containsInAnyOrder("pnt-1", "pnt-2")); assertThat(cs.getPropertyNames(), containsInAnyOrder("pn-1", "pn-2")); ChangeSet cs2 = new ChangeSet(2, of("p-2", "p-3"), of("nn-2"), of("pnt-2"), of("pn-2"), of("nt-2")); cs = cb1.add(cs2).build(); assertNull(cs.getParentPaths()); }
@Test public void manyIncludePaths() throws Exception { int numPaths = 50; ChangeSetBuilder builder = newBuilder(50, 9); for (int i = 0; i < numPaths; i++) { builder.addParentPath("/a/b/c/d/e/n" + i); } ChangeSet cs = builder.build(); Set<String> includes = Sets.newHashSet(); for (int i = 0; i < 100; i++) { includes.add("/foo/bar/n-" + i + "/*.jsp"); } ChangeSetFilter filter = new ChangeSetFilterImpl(s(),true, includes, s(), s(), s(), s()); // warm up doManyIncludePaths(filter, cs); // and measure Stopwatch sw = Stopwatch.createStarted(); doManyIncludePaths(filter, cs); LOG.info("manyIncludePaths() took {}", sw.stop()); }
@Test public void testIncludeOnParentPathsOverflow() throws Exception { ChangeSetBuilder builder = sampleBuilder(); ChangeSetFilterImpl prefilter = new ChangeSetFilterImpl(s("/"), true, null, s("/excluded"), s("foo", "bars"), s("nt:file"), s()); assertTrue(prefilter.excludes(builder.build())); overflowParentPaths(builder); assertFalse(prefilter.excludes(builder.build())); }
@Test public void testIncludeOnPropertyNamesOverflow() throws Exception { ChangeSetBuilder builder = sampleBuilder(); ChangeSetFilterImpl prefilter = new ChangeSetFilterImpl(s("/"), true, null, s("/excluded"), s("foo", "bars"), s("nt:file"), s()); assertTrue(prefilter.excludes(builder.build())); overflowPropertyNames(builder); assertFalse(prefilter.excludes(builder.build())); }
@Test public void testIncludeOnAllNodeTypeOverflow() throws Exception { ChangeSetBuilder builder = sampleBuilder(); ChangeSetFilterImpl prefilter = new ChangeSetFilterImpl(s("/"), true, null, s("/excluded"), s("foo", "bars"), s("nt:file"), s()); assertTrue(prefilter.excludes(builder.build())); overflowAllNodeTypes(builder); assertFalse(prefilter.excludes(builder.build())); }
@Test public void testIncludeOnParentNodeNameOverflow() throws Exception { ChangeSetBuilder builder = sampleBuilder(); ChangeSetFilterImpl prefilter = new ChangeSetFilterImpl(s("/"), true, null, s("/excluded"), s("foo", "bars"), s("nt:file"), s()); assertTrue(prefilter.excludes(builder.build())); overflowParentNodeNames(builder); assertFalse(prefilter.excludes(builder.build())); }
@Test public void testIncludeOnParentNodeTypeOverflow() throws Exception { ChangeSetBuilder builder = sampleBuilder(); ChangeSetFilterImpl prefilter = new ChangeSetFilterImpl(s("/"), true, null, s("/excluded"), s("foo", "bars"), s("nt:file"), s()); assertTrue(prefilter.excludes(builder.build())); overflowParentNodeTypes(builder); assertFalse(prefilter.excludes(builder.build())); }
@Test public void overflowAllNodeTypes() throws Exception{ ChangeSetBuilder cb1 = new ChangeSetBuilder(2, 2); add(cb1, "1"); ChangeSet cs1 = new ChangeSet(2, of("p-2"), of("nn-2"), of("pnt-2"), of("pn-2"), null); ChangeSet cs = cb1.add(cs1).build(); assertNull(cs.getAllNodeTypes()); assertThat(cs.getParentPaths(), containsInAnyOrder("p-1", "p-2")); assertThat(cs.getParentNodeNames(), containsInAnyOrder("nn-1", "nn-2")); assertThat(cs.getParentNodeTypes(), containsInAnyOrder("pnt-1", "pnt-2")); assertThat(cs.getPropertyNames(), containsInAnyOrder("pn-1", "pn-2")); }
@Test public void overflowParentNodeTypes() throws Exception{ ChangeSetBuilder cb1 = new ChangeSetBuilder(2, 2); add(cb1, "1"); ChangeSet cs1 = new ChangeSet(2, of("p-2"), of("nn-2"), null, of("pn-2"), of("nt-2")); ChangeSet cs = cb1.add(cs1).build(); assertNull(cs.getParentNodeTypes()); assertThat(cs.getParentPaths(), containsInAnyOrder("p-1", "p-2")); assertThat(cs.getAllNodeTypes(), containsInAnyOrder("nt-1", "nt-2")); assertThat(cs.getParentNodeNames(), containsInAnyOrder("nn-1", "nn-2")); assertThat(cs.getPropertyNames(), containsInAnyOrder("pn-1", "pn-2")); }
@Test public void overflowPropertyNames() throws Exception{ ChangeSetBuilder cb1 = new ChangeSetBuilder(2, 2); add(cb1, "1"); ChangeSet cs1 = new ChangeSet(2, of("p-2"), of("nn-2"), of("pnt-2"), null, of("nt-2")); ChangeSet cs = cb1.add(cs1).build(); assertNull(cs.getPropertyNames()); assertThat(cs.getParentPaths(), containsInAnyOrder("p-1", "p-2")); assertThat(cs.getAllNodeTypes(), containsInAnyOrder("nt-1", "nt-2")); assertThat(cs.getParentNodeNames(), containsInAnyOrder("nn-1", "nn-2")); assertThat(cs.getParentNodeTypes(), containsInAnyOrder("pnt-1", "pnt-2")); }
@Test public void pathDepth() throws Exception{ ChangeSetBuilder cb = new ChangeSetBuilder(10, 2); cb.addParentPath("/a/b"); cb.addParentPath("/x"); cb.addParentPath("/p/q/r"); ChangeSet cs = cb.build(); assertThat(cs.getParentPaths(), containsInAnyOrder("/a/b", "/x", "/p/q")); }
@Test public void basicMerge() throws Exception{ ChangeSetBuilder cb1 = new ChangeSetBuilder(5, 2); add(cb1, "1"); ChangeSetBuilder cb2 = new ChangeSetBuilder(5, 2); add(cb2, "2"); ChangeSet cs = cb1.add(cb2.build()).build(); assertThat(cs.getAllNodeTypes(), containsInAnyOrder("nt-1", "nt-2")); assertThat(cs.getParentPaths(), containsInAnyOrder("p-1", "p-2")); assertThat(cs.getParentNodeNames(), containsInAnyOrder("nn-1", "nn-2")); assertThat(cs.getParentNodeTypes(), containsInAnyOrder("pnt-1", "pnt-2")); assertThat(cs.getPropertyNames(), containsInAnyOrder("pn-1", "pn-2")); }
private ChangeSet newChangeSet(int maxPathDepth, Set<String> parentPaths, Set<String> parentNodeNames, Set<String> parentNodeTypes, Set<String> propertyNames, Set<String> allNodeTypes) { ChangeSetBuilder changeSetBuilder = new ChangeSetBuilder(Integer.MAX_VALUE, maxPathDepth); for (String path : parentPaths){ changeSetBuilder.addParentPath(path); } for (String nodeName : parentNodeNames){ changeSetBuilder.addParentNodeName(nodeName); } for (String parentNodeType : parentNodeTypes){ changeSetBuilder.addParentNodeType(parentNodeType); } for (String propertyName : propertyNames){ changeSetBuilder.addPropertyName(propertyName); } for (String nodeType : allNodeTypes){ changeSetBuilder.addNodeType(nodeType); } return changeSetBuilder.build(); }
@Test public void builderDepthMoreThanChangeSet() throws Exception{ ChangeSetBuilder cb1 = new ChangeSetBuilder(10, 8); cb1.addParentPath("/p"); cb1.addParentPath("/p/q"); cb1.addParentPath("/p/q/r"); cb1.addParentPath("/a/b/c/d"); cb1.addParentPath("/a/b/x/y/z"); ChangeSetBuilder cb2 = new ChangeSetBuilder(10, 2); cb2.addParentPath("/x"); cb2.addParentPath("/x/y"); cb1.add(cb2.build()); ChangeSet cs = cb1.build(); assertThat(cs.getParentPaths(), containsInAnyOrder( "/x", "/x/y", "/p", "/p/q", "/a/b" //Chopped paths )); assertEquals(cb2.getMaxPrefilterPathDepth(), cs.getMaxPrefilterPathDepth()); }
private void doTestDeepPath(String changeSetPath, String includePath, int maxPathDepth, boolean expectExclude) { ChangeSetBuilder builder = newBuilder(5, maxPathDepth); builder.addNodeType("nt:file"); builder.addParentNodeType("nt:file"); builder.addParentPath("/bar"); builder.addParentNodeName("bar"); builder.addPropertyName("a"); builder.addPropertyName("b"); builder.addParentPath(changeSetPath); builder.addParentNodeName(PathUtils.getName(changeSetPath)); ChangeSetFilterImpl prefilter = new ChangeSetFilterImpl(s(includePath), true, null, s("/excluded"), s("foo", "bars", "l"), s("nt:file"), s()); if (expectExclude) { assertTrue(prefilter.excludes(builder.build())); } else { assertFalse(prefilter.excludes(builder.build())); } }
@Test public void changeSetDepthMoreThanBuilder() throws Exception{ ChangeSetBuilder cb1 = new ChangeSetBuilder(10, 3); cb1.addParentPath("/x"); cb1.addParentPath("/x/y"); cb1.addParentPath("/x/y/z"); ChangeSetBuilder cb2 = new ChangeSetBuilder(10, 8); cb2.addParentPath("/p"); cb2.addParentPath("/p/q"); cb2.addParentPath("/p/q/r"); cb2.addParentPath("/a/b/c/d"); cb2.addParentPath("/a/b/x/y/z"); cb1.add(cb2.build()); ChangeSet cs = cb1.build(); assertThat(cs.getParentPaths(), containsInAnyOrder( "/x", "/x/y", "/x/y/z", "/p", "/p/q", "/p/q/r", "/a/b/c", "/a/b/x" //Chopped paths )); assertEquals(cb1.getMaxPrefilterPathDepth(), cs.getMaxPrefilterPathDepth()); }
@Test public void nullChangeSet() throws Exception{ ChangeSetBuilder cb1 = new ChangeSetBuilder(10, 8); add(cb1, "1"); cb1.add(null); ChangeSet cs = cb1.build(); assertNull(cs.getParentNodeTypes()); assertNull(cs.getParentNodeNames()); assertNull(cs.getParentPaths()); assertNull(cs.getAllNodeTypes()); assertNull(cs.getPropertyNames()); }