yang/yang-data-codec-xml/src/test/java/org/opendaylight/yangtools/yang/data/codec/xml/XmlToNormalizedNodesTest.java

   1 /*
   2  * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.yangtools.yang.data.codec.xml;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.junit.Assert.assertNotNull;
  13 import static org.junit.Assert.assertTrue;
  14 import static org.junit.Assert.fail;
  15
  16 import com.google.common.collect.ImmutableList;
  17 import java.io.IOException;
  18 import java.io.InputStream;
  19 import java.net.URI;
  20 import java.net.URISyntaxException;
  21 import java.util.Collections;
  22 import java.util.HashMap;
  23 import java.util.Map;
  24 import javax.xml.parsers.ParserConfigurationException;
  25 import javax.xml.stream.XMLInputFactory;
  26 import javax.xml.stream.XMLStreamException;
  27 import javax.xml.stream.XMLStreamReader;
  28 import org.junit.BeforeClass;
  29 import org.junit.Test;
  30 import org.opendaylight.yangtools.yang.common.QName;
  31 import org.opendaylight.yangtools.yang.common.QNameModule;
  32 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
  33 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  34 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
  35 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
  36 import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
  37 import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
  38 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  39 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
  40 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
  41 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
  42 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  43 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
  44 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
  45 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
  46 import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
  47 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
  48 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  49 import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
  50 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
  51 import org.xml.sax.SAXException;
  52
  53 public class XmlToNormalizedNodesTest {
  54
  55     private static SchemaContext schemaContext;
  56     private static ContainerSchemaNode outerContainerSchema;
  57     private static ContainerSchemaNode parentContainerSchema;
  58
  59     private static QNameModule fooModule;
  60     private static QName parentContainer;
  61
  62     private static QNameModule bazModule;
  63     private static QName outerContainer;
  64
  65     private static QName myContainer1;
  66     private static QName myKeyedList;
  67     private static QName myKeyLeaf;
  68     private static QName myLeafInList1;
  69     private static QName myLeafInList2;
  70     private static QName myLeaf1;
  71     private static QName myLeafList;
  72
  73     private static QName myContainer2;
  74     private static QName innerContainer;
  75     private static QName myLeaf2;
  76     private static QName myLeaf3;
  77     private static QName myChoice;
  78     private static QName myLeafInCase2;
  79
  80     private static QName myContainer3;
  81     private static QName myDoublyKeyedList;
  82     private static QName myFirstKeyLeaf;
  83     private static QName mySecondKeyLeaf;
  84     private static QName myLeafInList3;
  85
  86     @BeforeClass
  87     public static void setup() {
  88         fooModule = QNameModule.create(URI.create("foo-namespace"));
  89         parentContainer = QName.create(fooModule, "parent-container");
  90
  91         bazModule = QNameModule.create(URI.create("baz-namespace"));
  92         outerContainer = QName.create(bazModule, "outer-container");
  93
  94         myContainer1 = QName.create(bazModule, "my-container-1");
  95         myKeyedList = QName.create(bazModule, "my-keyed-list");
  96         myKeyLeaf = QName.create(bazModule, "my-key-leaf");
  97         myLeafInList1 = QName.create(bazModule, "my-leaf-in-list-1");
  98         myLeafInList2 = QName.create(bazModule, "my-leaf-in-list-2");
  99         myLeaf1 = QName.create(bazModule, "my-leaf-1");
 100         myLeafList = QName.create(bazModule, "my-leaf-list");
 101
 102         myContainer2 = QName.create(bazModule, "my-container-2");
 103         innerContainer = QName.create(bazModule, "inner-container");
 104         myLeaf2 = QName.create(bazModule, "my-leaf-2");
 105         myLeaf3 = QName.create(bazModule, "my-leaf-3");
 106         myChoice = QName.create(bazModule, "my-choice");
 107         myLeafInCase2 = QName.create(bazModule, "my-leaf-in-case-2");
 108
 109         myContainer3 = QName.create(bazModule, "my-container-3");
 110         myDoublyKeyedList = QName.create(bazModule, "my-doubly-keyed-list");
 111         myFirstKeyLeaf = QName.create(bazModule, "my-first-key-leaf");
 112         mySecondKeyLeaf = QName.create(bazModule, "my-second-key-leaf");
 113         myLeafInList3 = QName.create(bazModule, "my-leaf-in-list-3");
 114
 115         schemaContext = YangParserTestUtils.parseYangResourceDirectory("/");
 116         parentContainerSchema = (ContainerSchemaNode) SchemaContextUtil.findNodeInSchemaContext(schemaContext,
 117                 ImmutableList.of(parentContainer));
 118         outerContainerSchema = (ContainerSchemaNode) SchemaContextUtil.findNodeInSchemaContext(schemaContext,
 119                 ImmutableList.of(outerContainer));
 120     }
 121
 122     @Test
 123     public void testComplexXmlParsing() throws IOException, SAXException, URISyntaxException, XMLStreamException,
 124             ParserConfigurationException {
 125         final InputStream resourceAsStream = XmlToNormalizedNodesTest.class.getResourceAsStream("/baz.xml");
 126
 127         final XMLInputFactory factory = XMLInputFactory.newInstance();
 128         final XMLStreamReader reader = factory.createXMLStreamReader(resourceAsStream);
 129
 130         final NormalizedNodeResult result = new NormalizedNodeResult();
 131         final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
 132
 133         final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, outerContainerSchema);
 134         xmlParser.parse(reader);
 135
 136         xmlParser.flush();
 137         xmlParser.close();
 138
 139         final NormalizedNode<?, ?> transformedInput = result.getResult();
 140         assertNotNull(transformedInput);
 141
 142         final NormalizedNode<?, ?> expectedNormalizedNode = buildOuterContainerNode();
 143         assertNotNull(expectedNormalizedNode);
 144
 145         assertEquals(expectedNormalizedNode, transformedInput);
 146     }
 147
 148     @Test
 149     public void testSimpleXmlParsing() throws IOException, URISyntaxException, XMLStreamException,
 150             ParserConfigurationException, SAXException {
 151         final InputStream resourceAsStream = XmlToNormalizedNodesTest.class.getResourceAsStream("/foo.xml");
 152
 153         final XMLInputFactory factory = XMLInputFactory.newInstance();
 154         final XMLStreamReader reader = factory.createXMLStreamReader(resourceAsStream);
 155
 156         final NormalizedNodeResult result = new NormalizedNodeResult();
 157         final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
 158
 159         final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, parentContainerSchema);
 160         xmlParser.parse(reader);
 161
 162         final NormalizedNode<?, ?> transformedInput = result.getResult();
 163         assertNotNull(transformedInput);
 164     }
 165
 166     @Test
 167     public void shouldFailOnDuplicateLeaf() throws XMLStreamException, IOException,
 168             ParserConfigurationException, SAXException, URISyntaxException {
 169         final InputStream resourceAsStream = XmlToNormalizedNodesTest.class.getResourceAsStream("/invalid-foo.xml");
 170
 171         final XMLInputFactory factory = XMLInputFactory.newInstance();
 172         final XMLStreamReader reader = factory.createXMLStreamReader(resourceAsStream);
 173
 174         final NormalizedNodeResult result = new NormalizedNodeResult();
 175         final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
 176
 177         final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, parentContainerSchema);
 178         try {
 179             xmlParser.parse(reader);
 180             fail("IllegalStateException should have been thrown because of duplicate leaf.");
 181         } catch (IllegalStateException ex) {
 182             assertTrue(ex.getMessage().contains("Duplicate element \"decimal64-leaf\" in XML input"));
 183         }
 184
 185     }
 186
 187     @Test
 188     public void shouldFailOnDuplicateAnyXml() throws XMLStreamException, IOException,
 189             ParserConfigurationException, SAXException, URISyntaxException {
 190         final InputStream resourceAsStream = XmlToNormalizedNodesTest.class.getResourceAsStream("/invalid-foo-2.xml");
 191
 192         final XMLInputFactory factory = XMLInputFactory.newInstance();
 193         final XMLStreamReader reader = factory.createXMLStreamReader(resourceAsStream);
 194
 195         final NormalizedNodeResult result = new NormalizedNodeResult();
 196         final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
 197
 198         final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, parentContainerSchema);
 199         try {
 200             xmlParser.parse(reader);
 201             fail("IllegalStateException should have been thrown because of duplicate anyxml");
 202         } catch (IllegalStateException ex) {
 203             assertTrue(ex.getMessage().contains("Duplicate element \"my-anyxml\" in XML input"));
 204         }
 205     }
 206
 207     @Test
 208     public void shouldFailOnDuplicateContainer() throws XMLStreamException, IOException,
 209             ParserConfigurationException, SAXException, URISyntaxException {
 210         final InputStream resourceAsStream = XmlToNormalizedNodesTest.class.getResourceAsStream("/invalid-foo-3.xml");
 211
 212         final XMLInputFactory factory = XMLInputFactory.newInstance();
 213         final XMLStreamReader reader = factory.createXMLStreamReader(resourceAsStream);
 214
 215         final NormalizedNodeResult result = new NormalizedNodeResult();
 216         final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
 217
 218         final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, parentContainerSchema);
 219         try {
 220             xmlParser.parse(reader);
 221             fail("IllegalStateException should have been thrown because of duplicate container");
 222         } catch (IllegalStateException ex) {
 223             assertTrue(ex.getMessage().contains("Duplicate element \"leaf-container\" in XML input"));
 224         }
 225     }
 226
 227     @Test
 228     public void shouldFailOnUnterminatedLeafElement() throws XMLStreamException, IOException,
 229             ParserConfigurationException, SAXException, URISyntaxException {
 230         final InputStream resourceAsStream = XmlToNormalizedNodesTest.class.getResourceAsStream("/invalid-baz.xml");
 231
 232         final XMLInputFactory factory = XMLInputFactory.newInstance();
 233         final XMLStreamReader reader = factory.createXMLStreamReader(resourceAsStream);
 234
 235         final NormalizedNodeResult result = new NormalizedNodeResult();
 236         final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
 237
 238         final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, outerContainerSchema);
 239         try {
 240             xmlParser.parse(reader);
 241             fail("XMLStreamException should have been thrown because of unterminated leaf element.");
 242         } catch (XMLStreamException ex) {
 243             assertTrue(ex.getMessage().contains("elementGetText() function expects text only elment but "
 244                         + "START_ELEMENT was encountered."));
 245         }
 246     }
 247
 248     @Test
 249     public void shouldFailOnUnterminatedLeafElement2() throws XMLStreamException, IOException,
 250             ParserConfigurationException, SAXException, URISyntaxException {
 251         final InputStream resourceAsStream = XmlToNormalizedNodesTest.class.getResourceAsStream("/invalid-baz-2.xml");
 252
 253         final XMLInputFactory factory = XMLInputFactory.newInstance();
 254         final XMLStreamReader reader = factory.createXMLStreamReader(resourceAsStream);
 255
 256         final NormalizedNodeResult result = new NormalizedNodeResult();
 257         final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
 258
 259         final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, outerContainerSchema);
 260         try {
 261             xmlParser.parse(reader);
 262             fail("XMLStreamException should have been thrown because of unterminated leaf element.");
 263         } catch (XMLStreamException ex) {
 264             assertTrue(ex.getMessage().contains("The element type \"my-leaf-1\" must be terminated by the matching "
 265                         + "end-tag \"</my-leaf-1>\"."));
 266         }
 267     }
 268
 269     @Test
 270     public void shouldFailOnUnterminatedContainerElement() throws XMLStreamException, IOException,
 271             ParserConfigurationException, SAXException, URISyntaxException {
 272         final InputStream resourceAsStream = XmlToNormalizedNodesTest.class.getResourceAsStream("/invalid-baz-4.xml");
 273
 274         final XMLInputFactory factory = XMLInputFactory.newInstance();
 275         final XMLStreamReader reader = factory.createXMLStreamReader(resourceAsStream);
 276
 277         final NormalizedNodeResult result = new NormalizedNodeResult();
 278         final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
 279
 280         final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, outerContainerSchema);
 281         try {
 282             xmlParser.parse(reader);
 283             fail("XMLStreamException should have been thrown because of unterminated container element.");
 284         } catch (XMLStreamException ex) {
 285             assertTrue(ex.getMessage().contains("The element type \"my-container-1\" must be terminated by the "
 286                         + "matching end-tag \"</my-container-1>\"."));
 287         }
 288     }
 289
 290     @Test
 291     public void shouldFailOnUnknownChildNode() throws XMLStreamException, IOException,
 292             ParserConfigurationException, SAXException, URISyntaxException {
 293         final InputStream resourceAsStream = XmlToNormalizedNodesTest.class.getResourceAsStream("/invalid-baz-3.xml");
 294
 295         final XMLInputFactory factory = XMLInputFactory.newInstance();
 296         final XMLStreamReader reader = factory.createXMLStreamReader(resourceAsStream);
 297
 298         final NormalizedNodeResult result = new NormalizedNodeResult();
 299         final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
 300
 301         final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, outerContainerSchema);
 302         try {
 303             xmlParser.parse(reader);
 304             fail("IllegalStateException should have been thrown because of an unknown child node.");
 305         } catch (IllegalStateException ex) {
 306             assertEquals("Schema for node with name my-container-1 and namespace baz-namespace doesn't exist at "
 307                     + "AbsoluteSchemaPath{path=[(baz-namespace)outer-container, (baz-namespace)my-container-1]}",
 308                     ex.getMessage());
 309         }
 310     }
 311
 312     private static NormalizedNode<?, ?> buildOuterContainerNode() {
 313         // my-container-1
 314         MapNode myKeyedListNode = Builders.mapBuilder().withNodeIdentifier(new NodeIdentifier(myKeyedList))
 315                 .withChild(Builders.mapEntryBuilder().withNodeIdentifier(
 316                         new NodeIdentifierWithPredicates(myKeyedList, myKeyLeaf, "listkeyvalue1"))
 317                         .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInList1))
 318                                 .withValue("listleafvalue1").build())
 319                         .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInList2))
 320                                 .withValue("listleafvalue2").build()).build())
 321                 .withChild(Builders.mapEntryBuilder().withNodeIdentifier(
 322                         new NodeIdentifierWithPredicates(myKeyedList, myKeyLeaf, "listkeyvalue2"))
 323                         .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInList1))
 324                                 .withValue("listleafvalue12").build())
 325                         .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInList2))
 326                                 .withValue("listleafvalue22").build()).build()).build();
 327
 328         LeafNode<?> myLeaf1Node = Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeaf1))
 329                 .withValue("value1").build();
 330
 331         LeafSetNode<?> myLeafListNode = Builders.leafSetBuilder().withNodeIdentifier(new NodeIdentifier(myLeafList))
 332                 .withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(
 333                         new NodeWithValue<>(myLeafList, "lflvalue1")).withValue("lflvalue1").build())
 334                 .withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(
 335                         new NodeWithValue<>(myLeafList, "lflvalue2")).withValue("lflvalue2").build()).build();
 336
 337         ContainerNode myContainer1Node = Builders.containerBuilder().withNodeIdentifier(
 338                 new NodeIdentifier(myContainer1))
 339                 .withChild(myKeyedListNode)
 340                 .withChild(myLeaf1Node)
 341                 .withChild(myLeafListNode).build();
 342
 343         // my-container-2
 344         ContainerNode innerContainerNode = Builders.containerBuilder().withNodeIdentifier(
 345                 new NodeIdentifier(innerContainer))
 346                 .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeaf2))
 347                         .withValue("value2").build()).build();
 348
 349         LeafNode<?> myLeaf3Node = Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeaf3))
 350                 .withValue("value3").build();
 351
 352         ChoiceNode myChoiceNode = Builders.choiceBuilder().withNodeIdentifier(new NodeIdentifier(myChoice))
 353                 .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInCase2))
 354                         .withValue("case2value").build()).build();
 355
 356         ContainerNode myContainer2Node = Builders.containerBuilder().withNodeIdentifier(
 357                 new NodeIdentifier(myContainer2))
 358                 .withChild(innerContainerNode)
 359                 .withChild(myLeaf3Node)
 360                 .withChild(myChoiceNode).build();
 361
 362         // my-container-3
 363         Map<QName, Object> keys = new HashMap<>();
 364         keys.put(myFirstKeyLeaf, "listkeyvalue1");
 365         keys.put(mySecondKeyLeaf, "listkeyvalue2");
 366
 367         MapNode myDoublyKeyedListNode = Builders.mapBuilder().withNodeIdentifier(new NodeIdentifier(myDoublyKeyedList))
 368                 .withChild(Builders.mapEntryBuilder().withNodeIdentifier(
 369                         new NodeIdentifierWithPredicates(myDoublyKeyedList, keys))
 370                         .withChild(Builders.leafBuilder().withNodeIdentifier(
 371                                 new NodeIdentifier(myLeafInList3)).withValue("listleafvalue1").build()).build())
 372                 .build();
 373
 374         AugmentationNode myDoublyKeyedListAugNode = Builders.augmentationBuilder().withNodeIdentifier(
 375                 new AugmentationIdentifier(Collections.singleton(myDoublyKeyedList)))
 376                 .withChild(myDoublyKeyedListNode).build();
 377
 378         ContainerNode myContainer3Node = Builders.containerBuilder().withNodeIdentifier(
 379                 new NodeIdentifier(myContainer3))
 380                 .withChild(myDoublyKeyedListAugNode).build();
 381
 382         AugmentationNode myContainer3AugNode = Builders.augmentationBuilder().withNodeIdentifier(
 383                 new AugmentationIdentifier(Collections.singleton(myContainer3)))
 384                 .withChild(myContainer3Node).build();
 385
 386         ContainerNode outerContainerNode = Builders.containerBuilder().withNodeIdentifier(
 387                 new NodeIdentifier(outerContainer))
 388                 .withChild(myContainer1Node)
 389                 .withChild(myContainer2Node)
 390                 .withChild(myContainer3AugNode).build();
 391
 392         return outerContainerNode;
 393     }
 394 }