X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-clustering-commons%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fcluster%2Fdatastore%2Fnode%2Futils%2Ftransformer%2FNormalizedNodePrunerTest.java;h=422b9ce9c57ea8014af746dd83d555558e6a8bd1;hp=26c73480ce4ba0e937c5826a808fadb40d21bdcb;hb=a0025465e4951c9a0521feb07af697ec4aa8d2aa;hpb=ecccb6d5b43dd73aef0d2d19349d19ee9b4728f7 diff --git a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/transformer/NormalizedNodePrunerTest.java b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/transformer/NormalizedNodePrunerTest.java index 26c73480ce..422b9ce9c5 100644 --- a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/transformer/NormalizedNodePrunerTest.java +++ b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/transformer/NormalizedNodePrunerTest.java @@ -5,75 +5,69 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ - package org.opendaylight.controller.cluster.datastore.node.utils.transformer; import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertNotEquals; import static org.junit.Assert.assertTrue; -import static org.mockito.Matchers.any; -import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.never; -import static org.mockito.Mockito.verify; -import com.google.common.collect.ImmutableMap; -import com.google.common.collect.ImmutableSet; +import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapEntry; +import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapEntryBuilder; +import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapNodeBuilder; + +import com.google.common.collect.Sets; import java.io.IOException; +import java.util.Optional; import java.util.concurrent.atomic.AtomicInteger; import javax.xml.transform.dom.DOMSource; -import org.junit.Assert; -import org.junit.Before; import org.junit.Test; -import org.mockito.ArgumentCaptor; -import org.mockito.Mock; -import org.mockito.MockitoAnnotations; +import org.junit.runner.RunWith; +import org.mockito.junit.MockitoJUnitRunner; import org.opendaylight.controller.cluster.datastore.node.utils.NormalizedNodeNavigator; -import org.opendaylight.controller.cluster.datastore.node.utils.NormalizedNodeVisitor; import org.opendaylight.controller.cluster.datastore.util.TestModel; -import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue; +import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode; +import org.opendaylight.yangtools.yang.data.api.schema.LeafNode; import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode; +import org.opendaylight.yangtools.yang.data.api.schema.MapNode; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeWriter; import org.opendaylight.yangtools.yang.data.impl.schema.Builders; import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes; -import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder; -import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder; -import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder; -import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.ListNodeBuilder; -import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeContainerBuilder; import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetEntryNodeBuilder; import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetNodeBuilder; +import org.opendaylight.yangtools.yang.model.api.SchemaContext; +@RunWith(MockitoJUnitRunner.StrictStubs.class) public class NormalizedNodePrunerTest { + private static final SchemaContext NO_TEST_SCHEMA = TestModel.createTestContextWithoutTestSchema(); + private static final SchemaContext NO_AUG_SCHEMA = TestModel.createTestContextWithoutAugmentationSchema(); + private static final SchemaContext FULL_SCHEMA = TestModel.createTestContext(); + + private static AbstractNormalizedNodePruner prunerFullSchema(final YangInstanceIdentifier path) { + final ReusableNormalizedNodePruner pruner = ReusableNormalizedNodePruner.forSchemaContext(FULL_SCHEMA); + pruner.initializeForPath(path); + return pruner; + } - private NormalizedNodePruner prunerFullSchema; - - private NormalizedNodePruner prunerNoAugSchema; - - @Mock - private NormalizedNodeBuilderWrapper normalizedNodeBuilderWrapper; - - @Mock - private NormalizedNodeContainerBuilder normalizedNodeContainerBuilder; - - @Mock - private NormalizedNode normalizedNode; + private static AbstractNormalizedNodePruner prunerNoAugSchema(final YangInstanceIdentifier path) { + final ReusableNormalizedNodePruner pruner = ReusableNormalizedNodePruner.forSchemaContext(NO_AUG_SCHEMA); + pruner.initializeForPath(path); + return pruner; + } - @Before - public void setUp(){ - MockitoAnnotations.initMocks(this); - prunerFullSchema = new NormalizedNodePruner(TestModel.createTestContext()); - prunerNoAugSchema = new NormalizedNodePruner(TestModel.createTestContextWithoutAugmentationSchema()); - doReturn(normalizedNodeContainerBuilder).when(normalizedNodeBuilderWrapper).builder(); - doReturn(TestModel.BOOLEAN_LEAF_QNAME).when(normalizedNodeBuilderWrapper).nodeType(); - doReturn(normalizedNode).when(normalizedNodeContainerBuilder).build(); - doReturn(new YangInstanceIdentifier.NodeIdentifier(TestModel.BOOLEAN_LEAF_QNAME)).when(normalizedNodeBuilderWrapper).identifier(); + private static AbstractNormalizedNodePruner prunerNoTestSchema(final YangInstanceIdentifier path) { + final ReusableNormalizedNodePruner pruner = ReusableNormalizedNodePruner.forSchemaContext(NO_TEST_SCHEMA); + pruner.initializeForPath(path); + return pruner; } @Test public void testNodesNotPrunedWhenSchemaPresent() throws IOException { - NormalizedNodePruner pruner = prunerFullSchema; + AbstractNormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH); NormalizedNodeWriter normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(pruner); @@ -81,7 +75,7 @@ public class NormalizedNodePrunerTest { normalizedNodeWriter.write(expected); - NormalizedNode actual = pruner.normalizedNode(); + NormalizedNode actual = pruner.getResult().orElseThrow(); assertEquals(expected, actual); @@ -89,7 +83,7 @@ public class NormalizedNodePrunerTest { @Test(expected = IllegalStateException.class) public void testReusePruner() throws IOException { - NormalizedNodePruner pruner = prunerFullSchema; + AbstractNormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH); NormalizedNodeWriter normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(pruner); @@ -97,7 +91,7 @@ public class NormalizedNodePrunerTest { normalizedNodeWriter.write(expected); - NormalizedNode actual = pruner.normalizedNode(); + NormalizedNode actual = pruner.getResult().orElseThrow(); assertEquals(expected, actual); @@ -107,8 +101,8 @@ public class NormalizedNodePrunerTest { @Test - public void testNodesPrunedWhenAugmentationSchemaNotPresent() throws IOException { - NormalizedNodePruner pruner = prunerNoAugSchema; + public void testNodesPrunedWhenAugmentationSchemaMissing() throws IOException { + AbstractNormalizedNodePruner pruner = prunerNoAugSchema(TestModel.TEST_PATH); NormalizedNodeWriter normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(pruner); @@ -116,9 +110,9 @@ public class NormalizedNodePrunerTest { normalizedNodeWriter.write(expected); - NormalizedNode actual = pruner.normalizedNode(); + NormalizedNode actual = pruner.getResult().orElseThrow(); - Assert.assertNotEquals(expected, actual); + assertNotEquals(expected, actual); // Asserting true here instead of checking actual value because I don't want this assertion to be fragile assertTrue(countNodes(expected, "store:aug") > 0); @@ -128,8 +122,8 @@ public class NormalizedNodePrunerTest { } @Test - public void testNodesPrunedWhenTestSchemaNotPresent() throws IOException { - NormalizedNodePruner pruner = new NormalizedNodePruner(TestModel.createTestContextWithoutTestSchema()); + public void testNodesPrunedWhenTestSchemaMissing() throws IOException { + AbstractNormalizedNodePruner pruner = prunerNoTestSchema(TestModel.TEST_PATH); NormalizedNodeWriter normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(pruner); @@ -137,274 +131,259 @@ public class NormalizedNodePrunerTest { normalizedNodeWriter.write(expected); - NormalizedNode actual = pruner.normalizedNode(); - - // Since top level schema is missing null is returned - assertNull(actual); + // Since top level schema is missing empty is returned + assertEquals(Optional.empty(), pruner.getResult()); // Asserting true here instead of checking actual value because I don't want this assertion to be fragile assertTrue(countNodes(expected, "urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test") > 0); } - - private static int countNodes(NormalizedNode normalizedNode, final String namespaceFilter){ - if(normalizedNode == null){ + private static int countNodes(final NormalizedNode normalizedNode, final String namespaceFilter) { + if (normalizedNode == null) { return 0; } final AtomicInteger count = new AtomicInteger(); - new NormalizedNodeNavigator(new NormalizedNodeVisitor() { - - @Override - public void visitNode(int level, String parentPath, NormalizedNode normalizedNode) { - if(!(normalizedNode.getIdentifier() instanceof YangInstanceIdentifier.AugmentationIdentifier)) { - if (normalizedNode.getIdentifier().getNodeType().getNamespace().toString().contains(namespaceFilter)) { - count.incrementAndGet(); - } + new NormalizedNodeNavigator((level, parentPath, normalizedNode1) -> { + if (!(normalizedNode1.getIdentifier() instanceof AugmentationIdentifier)) { + if (normalizedNode1.getIdentifier().getNodeType().getNamespace().toString().contains(namespaceFilter)) { + count.incrementAndGet(); } } - }).navigate(YangInstanceIdentifier.builder().build().toString(), normalizedNode); + }).navigate(YangInstanceIdentifier.empty().toString(), normalizedNode); return count.get(); } - @Test(expected = IllegalStateException.class) - public void testLeafNodeHasNoParent() throws IOException { - prunerFullSchema.leafNode(new YangInstanceIdentifier.NodeIdentifier(TestModel.BOOLEAN_LEAF_QNAME), mock(Object.class)); - } - @Test - public void testLeafNodeHasParent() throws IOException { - prunerFullSchema.stack().push(normalizedNodeBuilderWrapper); - Object o = mock(Object.class); - prunerFullSchema.leafNode(new YangInstanceIdentifier.NodeIdentifier(TestModel.BOOLEAN_LEAF_QNAME), o); - - ArgumentCaptor captor = ArgumentCaptor.forClass(NormalizedNode.class); - - verify(normalizedNodeContainerBuilder).addChild(captor.capture()); - - NormalizedNode value = captor.getValue(); - assertEquals(normalizedNodeBuilderWrapper.identifier().getNodeType(), value.getNodeType()); - assertEquals(normalizedNodeBuilderWrapper.identifier(), value.getIdentifier()); - assertEquals(o, value.getValue()); + public void testLeafNodeNotPrunedWhenHasNoParent() throws IOException { + AbstractNormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH.node(TestModel.DESC_QNAME)); + NormalizedNode input = Builders.leafBuilder().withNodeIdentifier( + new NodeIdentifier(TestModel.DESC_QNAME)).withValue("test").build(); + NormalizedNodeWriter.forStreamWriter(pruner).write(input); + assertEquals("normalizedNode", input, pruner.getResult().orElseThrow()); } @Test - public void testLeafNodeSchemaMissing() throws IOException { - prunerNoAugSchema.stack().push(normalizedNodeBuilderWrapper); - prunerNoAugSchema.leafNode(new YangInstanceIdentifier.NodeIdentifier(TestModel.AUG_CONT_QNAME), mock(Object.class)); - verify(normalizedNodeContainerBuilder, never()).addChild(any(NormalizedNode.class)); - } - - @Test(expected = IllegalStateException.class) - public void testLeafSetEntryNodeHasNoParent() throws IOException { - prunerFullSchema.leafSetEntryNode(mock(Object.class)); + public void testLeafNodePrunedWhenHasAugmentationParentAndSchemaMissing() throws IOException { + AugmentationIdentifier augId = new AugmentationIdentifier(Sets.newHashSet(TestModel.AUG_CONT_QNAME)); + AbstractNormalizedNodePruner pruner = prunerFullSchema(YangInstanceIdentifier.builder() + .node(TestModel.TEST_QNAME).node(TestModel.AUGMENTED_LIST_QNAME) + .node(TestModel.AUGMENTED_LIST_QNAME).node(augId).build()); + LeafNode child = Builders.leafBuilder().withNodeIdentifier( + new NodeIdentifier(TestModel.INVALID_QNAME)).withValue("test").build(); + NormalizedNode input = Builders.augmentationBuilder().withNodeIdentifier(augId).withChild(child).build(); + NormalizedNodeWriter.forStreamWriter(pruner).write(input); + + NormalizedNode actual = pruner.getResult().orElseThrow(); + assertEquals("normalizedNode", Builders.augmentationBuilder().withNodeIdentifier(augId).build(), actual); } @Test - public void testLeafSetEntryNodeHasParent() throws IOException { - prunerFullSchema.stack().push(normalizedNodeBuilderWrapper); - Object o = mock(Object.class); - YangInstanceIdentifier.PathArgument nodeIdentifier - = new YangInstanceIdentifier.NodeWithValue(normalizedNodeBuilderWrapper.identifier().getNodeType(), o); - prunerFullSchema.leafSetEntryNode(o); - - ArgumentCaptor captor = ArgumentCaptor.forClass(NormalizedNode.class); - - verify(normalizedNodeContainerBuilder).addChild(captor.capture()); - - NormalizedNode value = captor.getValue(); - assertEquals(nodeIdentifier.getNodeType(), value.getNodeType()); - assertEquals(nodeIdentifier, value.getIdentifier()); - assertEquals(o, value.getValue()); + public void testLeafNodePrunedWhenHasNoParentAndSchemaMissing() throws IOException { + AbstractNormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH.node(TestModel.INVALID_QNAME)); + NormalizedNode input = Builders.leafBuilder().withNodeIdentifier( + new NodeIdentifier(TestModel.INVALID_QNAME)).withValue("test").build(); + NormalizedNodeWriter.forStreamWriter(pruner).write(input); + assertEquals(Optional.empty(), pruner.getResult()); } @Test - public void testLeafSetEntryNodeSchemaMissing() throws IOException { - doReturn(new YangInstanceIdentifier.NodeIdentifier(TestModel.AUG_CONT_QNAME)).when(normalizedNodeBuilderWrapper).identifier(); - - prunerNoAugSchema.stack().push(normalizedNodeBuilderWrapper); - prunerNoAugSchema.leafSetEntryNode(new YangInstanceIdentifier.NodeIdentifier(TestModel.AUG_CONT_QNAME)); - - verify(normalizedNodeContainerBuilder, never()).addChild(any(NormalizedNode.class)); - } - - @Test(expected = IllegalStateException.class) - public void testAnyXMLNodeHasNoParent() throws IOException { - prunerFullSchema.anyxmlNode(new YangInstanceIdentifier.NodeIdentifier(TestModel.BOOLEAN_LEAF_QNAME), mock(Object.class)); - } - - @Test - public void testAnyXMLNodeHasParent() throws IOException { - prunerFullSchema.stack().push(normalizedNodeBuilderWrapper); - YangInstanceIdentifier.NodeIdentifier nodeIdentifier = new YangInstanceIdentifier.NodeIdentifier(TestModel.BOOLEAN_LEAF_QNAME); - DOMSource o = mock(DOMSource.class); - prunerFullSchema.anyxmlNode(nodeIdentifier, o); - - ArgumentCaptor captor = ArgumentCaptor.forClass(NormalizedNode.class); - - verify(normalizedNodeContainerBuilder).addChild(captor.capture()); - - NormalizedNode value = captor.getValue(); - assertEquals(nodeIdentifier.getNodeType(), value.getNodeType()); - assertEquals(nodeIdentifier, value.getIdentifier()); - assertEquals(o, value.getValue()); + public void testLeafSetEntryNodeNotPrunedWhenHasNoParent() throws IOException { + AbstractNormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH.node(TestModel.SHOE_QNAME)); + NormalizedNode input = Builders.leafSetEntryBuilder().withValue("puma").withNodeIdentifier( + new NodeWithValue<>(TestModel.SHOE_QNAME, "puma")).build(); + NormalizedNodeWriter.forStreamWriter(pruner).write(input); + + NormalizedNode actual = pruner.getResult().orElseThrow(); + assertEquals("normalizedNode", input, actual); } @Test - public void testAnyXmlNodeSchemaMissing() throws IOException { - prunerNoAugSchema.stack().push(normalizedNodeBuilderWrapper); - prunerNoAugSchema.anyxmlNode(new YangInstanceIdentifier.NodeIdentifier(TestModel.AUG_CONT_QNAME), mock(DOMSource.class)); - - verify(normalizedNodeContainerBuilder, never()).addChild(any(NormalizedNode.class)); - - + public void testLeafSetEntryNodeNotPrunedWhenHasParent() throws IOException { + AbstractNormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH.node(TestModel.SHOE_QNAME)); + LeafSetEntryNode child = Builders.leafSetEntryBuilder().withValue("puma").withNodeIdentifier( + new NodeWithValue<>(TestModel.SHOE_QNAME, "puma")).build(); + NormalizedNode input = Builders.leafSetBuilder().withNodeIdentifier( + new NodeIdentifier(TestModel.SHOE_QNAME)).withChild(child).build(); + NormalizedNodeWriter.forStreamWriter(pruner).write(input); + + NormalizedNode actual = pruner.getResult().orElseThrow(); + assertEquals("normalizedNode", input, actual); } - @Test - public void testLeafSetPushesBuilderToStack() throws IOException { - prunerFullSchema.startLeafSet(new YangInstanceIdentifier.NodeIdentifier(TestModel.BOOLEAN_LEAF_QNAME), 10); + public void testLeafSetEntryNodePrunedWhenHasNoParentAndSchemaMissing() throws IOException { + AbstractNormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH.node(TestModel.INVALID_QNAME)); + NormalizedNode input = Builders.leafSetEntryBuilder().withValue("test").withNodeIdentifier( + new NodeWithValue<>(TestModel.INVALID_QNAME, "test")).build(); + NormalizedNodeWriter.forStreamWriter(pruner).write(input); - assertEquals(1, prunerFullSchema.stack().size()); - assertTrue(prunerFullSchema.stack().peek().toString(), prunerFullSchema.stack().peek() instanceof NormalizedNodeBuilderWrapper); - assertTrue(prunerFullSchema.stack().peek().builder().toString(), prunerFullSchema.stack().peek().builder() instanceof ListNodeBuilder); + assertEquals(Optional.empty(), pruner.getResult()); } @Test - public void testStartContainerNodePushesBuilderToStack() throws IOException { - prunerFullSchema.startContainerNode(new YangInstanceIdentifier.NodeIdentifier(TestModel.BOOLEAN_LEAF_QNAME), 10); - - assertEquals(1, prunerFullSchema.stack().size()); - assertTrue(prunerFullSchema.stack().peek().toString(), prunerFullSchema.stack().peek() instanceof NormalizedNodeBuilderWrapper); - assertTrue(prunerFullSchema.stack().peek().builder().toString(), prunerFullSchema.stack().peek().builder() instanceof DataContainerNodeAttrBuilder); + public void testLeafSetEntryNodePrunedWhenHasParentAndSchemaMissing() throws IOException { + AbstractNormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH.node(TestModel.INVALID_QNAME)); + LeafSetEntryNode child = Builders.leafSetEntryBuilder().withValue("test").withNodeIdentifier( + new NodeWithValue<>(TestModel.INVALID_QNAME, "test")).build(); + NormalizedNode input = Builders.leafSetBuilder().withNodeIdentifier( + new NodeIdentifier(TestModel.INVALID_QNAME)).withChild(child).build(); + NormalizedNodeWriter.forStreamWriter(pruner).write(input); + + assertEquals(Optional.empty(), pruner.getResult()); } @Test - public void testStartUnkeyedListPushesBuilderToStack() throws IOException { - prunerFullSchema.startUnkeyedList(new YangInstanceIdentifier.NodeIdentifier(TestModel.BOOLEAN_LEAF_QNAME), 10); - - assertEquals(1, prunerFullSchema.stack().size()); - assertTrue(prunerFullSchema.stack().peek().toString(), prunerFullSchema.stack().peek() instanceof NormalizedNodeBuilderWrapper); - assertTrue(prunerFullSchema.stack().peek().builder().toString(), prunerFullSchema.stack().peek().builder() instanceof CollectionNodeBuilder); + public void testAnyXMLNodeNotPrunedWhenHasNoParent() throws IOException { + AbstractNormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH.node(TestModel.ANY_XML_QNAME)); + NormalizedNode input = Builders.anyXmlBuilder().withNodeIdentifier( + new NodeIdentifier(TestModel.ANY_XML_QNAME)).withValue(mock(DOMSource.class)).build(); + NormalizedNodeWriter.forStreamWriter(pruner).write(input); + + NormalizedNode actual = pruner.getResult().orElseThrow(); + assertEquals("normalizedNode", input, actual); } @Test - public void testStartUnkeyedListItemPushesBuilderToStack() throws IOException { - prunerFullSchema.startUnkeyedListItem(new YangInstanceIdentifier.NodeIdentifier(TestModel.BOOLEAN_LEAF_QNAME), 10); - - assertEquals(1, prunerFullSchema.stack().size()); - assertTrue(prunerFullSchema.stack().peek().toString(), prunerFullSchema.stack().peek() instanceof NormalizedNodeBuilderWrapper); - assertTrue(prunerFullSchema.stack().peek().builder().toString(), prunerFullSchema.stack().peek().builder() instanceof DataContainerNodeAttrBuilder); + public void testAnyXMLNodeNotPrunedWhenHasParent() throws IOException { + AbstractNormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH); + DOMSourceAnyxmlNode child = Builders.anyXmlBuilder().withNodeIdentifier( + new NodeIdentifier(TestModel.ANY_XML_QNAME)).withValue(mock(DOMSource.class)).build(); + NormalizedNode input = Builders.containerBuilder().withNodeIdentifier( + new NodeIdentifier(TestModel.TEST_QNAME)).withChild(child).build(); + NormalizedNodeWriter.forStreamWriter(pruner).write(input); + + NormalizedNode actual = pruner.getResult().orElseThrow(); + assertEquals("normalizedNode", input, actual); } @Test - public void testStartMapNodePushesBuilderToStack() throws IOException { - prunerFullSchema.startMapNode(new YangInstanceIdentifier.NodeIdentifier(TestModel.BOOLEAN_LEAF_QNAME), 10); + public void testAnyXmlNodePrunedWhenHasNoParentAndSchemaMissing() throws IOException { + AbstractNormalizedNodePruner pruner = prunerNoTestSchema(TestModel.TEST_PATH.node(TestModel.ANY_XML_QNAME)); + NormalizedNode input = Builders.anyXmlBuilder().withNodeIdentifier( + new NodeIdentifier(TestModel.ANY_XML_QNAME)).withValue(mock(DOMSource.class)).build(); + NormalizedNodeWriter.forStreamWriter(pruner).write(input); - assertEquals(1, prunerFullSchema.stack().size()); - assertTrue(prunerFullSchema.stack().peek().toString(), prunerFullSchema.stack().peek() instanceof NormalizedNodeBuilderWrapper); - assertTrue(prunerFullSchema.stack().peek().builder().toString(), prunerFullSchema.stack().peek().builder() instanceof CollectionNodeBuilder); + assertEquals(Optional.empty(), pruner.getResult()); } @Test - public void testStartMapEntryNodePushesBuilderToStack() throws IOException { - prunerFullSchema.startMapEntryNode( - new YangInstanceIdentifier.NodeIdentifierWithPredicates(TestModel.BOOLEAN_LEAF_QNAME, - ImmutableMap.of(TestModel.BOOLEAN_LEAF_QNAME, "value")), 10); - - assertEquals(1, prunerFullSchema.stack().size()); - assertTrue(prunerFullSchema.stack().peek().toString(), prunerFullSchema.stack().peek() instanceof NormalizedNodeBuilderWrapper); - assertTrue(prunerFullSchema.stack().peek().builder().toString(), prunerFullSchema.stack().peek().builder() instanceof DataContainerNodeAttrBuilder); + public void testInnerContainerNodeWithFullPathPathNotPruned() throws IOException { + YangInstanceIdentifier path = YangInstanceIdentifier.builder().node(TestModel.TEST_QNAME) + .node(TestModel.OUTER_LIST_QNAME).nodeWithKey(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1) + .node(TestModel.INNER_LIST_QNAME).nodeWithKey(TestModel.INNER_LIST_QNAME, TestModel.NAME_QNAME, "one") + .node(TestModel.INNER_CONTAINER_QNAME).build(); + AbstractNormalizedNodePruner pruner = prunerFullSchema(path); + + NormalizedNode input = ImmutableNodes.containerNode(TestModel.INNER_CONTAINER_QNAME); + NormalizedNodeWriter.forStreamWriter(pruner).write(input); + + NormalizedNode actual = pruner.getResult().orElseThrow(); + assertEquals("normalizedNode", input, actual); } @Test - public void testStartOrderedMapNodePushesBuilderToStack() throws IOException { - prunerFullSchema.startOrderedMapNode(new YangInstanceIdentifier.NodeIdentifier(TestModel.BOOLEAN_LEAF_QNAME), 10); + public void testInnerContainerNodeWithFullPathPrunedWhenSchemaMissing() throws IOException { + YangInstanceIdentifier path = YangInstanceIdentifier.builder().node(TestModel.TEST_QNAME) + .node(TestModel.OUTER_LIST_QNAME).nodeWithKey(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1) + .node(TestModel.INNER_LIST_QNAME).nodeWithKey(TestModel.INNER_LIST_QNAME, TestModel.NAME_QNAME, "one") + .node(TestModel.INVALID_QNAME).build(); + AbstractNormalizedNodePruner pruner = prunerFullSchema(path); - assertEquals(1, prunerFullSchema.stack().size()); - assertTrue(prunerFullSchema.stack().peek().toString(), prunerFullSchema.stack().peek() instanceof NormalizedNodeBuilderWrapper); - assertTrue(prunerFullSchema.stack().peek().builder().toString(), prunerFullSchema.stack().peek().builder() instanceof CollectionNodeBuilder); - } - - @Test - public void testStartChoiceNodePushesBuilderToStack() throws IOException { - prunerFullSchema.startChoiceNode(new YangInstanceIdentifier.NodeIdentifier(TestModel.BOOLEAN_LEAF_QNAME), 10); + NormalizedNode input = ImmutableNodes.containerNode(TestModel.INVALID_QNAME); + NormalizedNodeWriter.forStreamWriter(pruner).write(input); - assertEquals(1, prunerFullSchema.stack().size()); - assertTrue(prunerFullSchema.stack().peek().toString(), prunerFullSchema.stack().peek() instanceof NormalizedNodeBuilderWrapper); - assertTrue(prunerFullSchema.stack().peek().builder().toString(), prunerFullSchema.stack().peek().builder() instanceof DataContainerNodeBuilder); + assertEquals(Optional.empty(), pruner.getResult()); } @Test - public void testStartAugmentationPushesBuilderToStack() throws IOException { - prunerFullSchema.startAugmentationNode(new YangInstanceIdentifier.AugmentationIdentifier(ImmutableSet.of(TestModel.AUG_CONT_QNAME))); - - assertEquals(1, prunerFullSchema.stack().size()); - assertTrue(prunerFullSchema.stack().peek().toString(), prunerFullSchema.stack().peek() instanceof NormalizedNodeBuilderWrapper); - assertTrue(prunerFullSchema.stack().peek().builder().toString(), prunerFullSchema.stack().peek().builder() instanceof DataContainerNodeBuilder); - } - - @Test(expected = IllegalStateException.class) - public void testEndNodeWhenNoBuildersOnStack() throws IOException { - prunerFullSchema.endNode(); + public void testInnerContainerNodeWithParentPathPrunedWhenSchemaMissing() throws IOException { + YangInstanceIdentifier path = YangInstanceIdentifier.builder().node(TestModel.TEST_QNAME) + .node(TestModel.OUTER_LIST_QNAME).nodeWithKey(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1) + .build(); + AbstractNormalizedNodePruner pruner = prunerFullSchema(path); + + MapNode innerList = mapNodeBuilder(TestModel.INNER_LIST_QNAME).withChild(mapEntryBuilder( + TestModel.INNER_LIST_QNAME, TestModel.NAME_QNAME, "one").withChild( + ImmutableNodes.containerNode(TestModel.INVALID_QNAME)).build()).build(); + NormalizedNode input = mapEntryBuilder(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1) + .withChild(innerList).build(); + NormalizedNodeWriter.forStreamWriter(pruner).write(input); + + NormalizedNode expected = mapEntryBuilder(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1) + .withChild(mapNodeBuilder(TestModel.INNER_LIST_QNAME).withChild(mapEntryBuilder( + TestModel.INNER_LIST_QNAME, TestModel.NAME_QNAME, "one").build()).build()).build(); + NormalizedNode actual = pruner.getResult().orElseThrow(); + assertEquals("normalizedNode", expected, actual); } @Test - public void testEndNodeWhenOneBuildersOnStack() throws IOException { - prunerFullSchema.stack().push(normalizedNodeBuilderWrapper); - prunerFullSchema.endNode(); - assertEquals(normalizedNode, prunerFullSchema.normalizedNode()); + public void testInnerListNodeWithFullPathNotPruned() throws IOException { + YangInstanceIdentifier path = YangInstanceIdentifier.builder().node(TestModel.TEST_QNAME) + .node(TestModel.OUTER_LIST_QNAME).nodeWithKey(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1) + .node(TestModel.INNER_LIST_QNAME).build(); + AbstractNormalizedNodePruner pruner = prunerFullSchema(path); + + MapNode input = mapNodeBuilder(TestModel.INNER_LIST_QNAME).withChild(mapEntryBuilder( + TestModel.INNER_LIST_QNAME, TestModel.NAME_QNAME, "one").withChild( + ImmutableNodes.containerNode(TestModel.INNER_CONTAINER_QNAME)).build()).build(); + NormalizedNodeWriter.forStreamWriter(pruner).write(input); + + NormalizedNode actual = pruner.getResult().orElseThrow(); + assertEquals("normalizedNode", input, actual); } @Test - public void testEndNodeSchemaMissing() throws IOException { - doReturn(new YangInstanceIdentifier.NodeIdentifier(TestModel.AUG_CONT_QNAME)).when(normalizedNodeBuilderWrapper).identifier(); - - prunerNoAugSchema.stack().push(normalizedNodeBuilderWrapper); - prunerNoAugSchema.endNode(); - - assertEquals(null, prunerNoAugSchema.normalizedNode()); + public void testInnerListNodeWithFullPathPrunedWhenSchemaMissing() throws IOException { + YangInstanceIdentifier path = YangInstanceIdentifier.builder().node(TestModel.TEST_QNAME) + .node(TestModel.OUTER_LIST_QNAME).nodeWithKey(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1) + .node(TestModel.INVALID_QNAME).build(); + AbstractNormalizedNodePruner pruner = prunerFullSchema(path); + + MapNode input = mapNodeBuilder(TestModel.INVALID_QNAME).withChild(mapEntryBuilder( + TestModel.INVALID_QNAME, TestModel.NAME_QNAME, "one").withChild( + ImmutableNodes.containerNode(TestModel.INNER_CONTAINER_QNAME)).build()).build(); + NormalizedNodeWriter.forStreamWriter(pruner).write(input); + + assertEquals(Optional.empty(), pruner.getResult()); } @Test - public void testEndNodeWhenMoreThanOneBuilderOnStack() throws IOException { - // A little lazy in adding the "parent" builder - prunerFullSchema.stack().push(normalizedNodeBuilderWrapper); - prunerFullSchema.stack().push(normalizedNodeBuilderWrapper); - prunerFullSchema.endNode(); - assertEquals(null, prunerFullSchema.normalizedNode()); - - verify(normalizedNodeContainerBuilder).addChild(any(NormalizedNode.class)); + public void testInnerListNodeWithParentPathPrunedWhenSchemaMissing() throws IOException { + YangInstanceIdentifier path = YangInstanceIdentifier.builder().node(TestModel.TEST_QNAME) + .node(TestModel.OUTER_LIST_QNAME).nodeWithKey(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1) + .build(); + AbstractNormalizedNodePruner pruner = prunerFullSchema(path); + + MapNode innerList = mapNodeBuilder(TestModel.INVALID_QNAME).withChild(mapEntryBuilder( + TestModel.INVALID_QNAME, TestModel.NAME_QNAME, "one").withChild( + ImmutableNodes.containerNode(TestModel.INNER_CONTAINER_QNAME)).build()).build(); + NormalizedNode input = mapEntryBuilder(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1) + .withChild(innerList).build(); + NormalizedNodeWriter.forStreamWriter(pruner).write(input); + + NormalizedNode expected = mapEntry(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1); + NormalizedNode actual = pruner.getResult().orElseThrow(); + assertEquals("normalizedNode", expected, actual); } private static NormalizedNode createTestContainer() { - byte[] bytes1 = {1,2,3}; + byte[] bytes1 = {1, 2, 3}; LeafSetEntryNode entry1 = ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier( - new YangInstanceIdentifier.NodeWithValue(TestModel.BINARY_LEAF_LIST_QNAME, bytes1)). - withValue(bytes1).build(); + new NodeWithValue<>(TestModel.BINARY_LEAF_LIST_QNAME, bytes1)).withValue(bytes1).build(); byte[] bytes2 = {}; LeafSetEntryNode entry2 = ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier( - new YangInstanceIdentifier.NodeWithValue(TestModel.BINARY_LEAF_LIST_QNAME, bytes2)). - withValue(bytes2).build(); - - LeafSetEntryNode entry3 = ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier( - new YangInstanceIdentifier.NodeWithValue(TestModel.BINARY_LEAF_LIST_QNAME, null)). - withValue(null).build(); - - - return TestModel.createBaseTestContainerBuilder(). - withChild(ImmutableLeafSetNodeBuilder.create().withNodeIdentifier( - new YangInstanceIdentifier.NodeIdentifier(TestModel.BINARY_LEAF_LIST_QNAME)). - withChild(entry1).withChild(entry2).withChild(entry3).build()). - withChild(ImmutableNodes.leafNode(TestModel.SOME_BINARY_DATA_QNAME, new byte[]{1, 2, 3, 4})). - withChild(Builders.orderedMapBuilder(). - withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.ORDERED_LIST_QNAME)). - withChild(ImmutableNodes.mapEntry(TestModel.ORDERED_LIST_ENTRY_QNAME, - TestModel.ID_QNAME, 11)).build()). - build(); + new NodeWithValue<>(TestModel.BINARY_LEAF_LIST_QNAME, bytes2)).withValue(bytes2).build(); + + return TestModel.createBaseTestContainerBuilder() + .withChild(ImmutableLeafSetNodeBuilder.create().withNodeIdentifier( + new NodeIdentifier(TestModel.BINARY_LEAF_LIST_QNAME)) + .withChild(entry1).withChild(entry2).build()) + .withChild(ImmutableNodes.leafNode(TestModel.SOME_BINARY_DATA_QNAME, new byte[]{1, 2, 3, 4})) + .build(); } -} \ No newline at end of file +}