codec/yang-data-codec-xml/src/test/java/org/opendaylight/yangtools/yang/data/codec/xml/SchemalessXMLStreamNormalizedNodeStreamWriterTest.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 package org.opendaylight.yangtools.yang.data.codec.xml;
   9
  10 import java.util.Map;
  11 import javax.xml.stream.XMLOutputFactory;
  12 import javax.xml.transform.dom.DOMResult;
  13 import org.custommonkey.xmlunit.Diff;
  14 import org.custommonkey.xmlunit.IgnoreTextAndAttributeValuesDifferenceListener;
  15 import org.custommonkey.xmlunit.XMLAssert;
  16 import org.custommonkey.xmlunit.XMLUnit;
  17 import org.junit.jupiter.api.BeforeEach;
  18 import org.junit.jupiter.params.ParameterizedTest;
  19 import org.junit.jupiter.params.provider.ArgumentsSource;
  20 import org.opendaylight.yangtools.util.xml.UntrustedXML;
  21 import org.opendaylight.yangtools.yang.common.QName;
  22 import org.opendaylight.yangtools.yang.common.QNameModule;
  23 import org.opendaylight.yangtools.yang.common.Revision;
  24 import org.opendaylight.yangtools.yang.common.XMLNamespace;
  25 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  26 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
  27 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
  28 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  29 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeWriter;
  30 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
  31 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
  32
  33 public class SchemalessXMLStreamNormalizedNodeStreamWriterTest extends AbstractXmlTest {
  34     private QNameModule foobarModule;
  35
  36     private QName outerContainer;
  37
  38     private QName myContainer1;
  39     private QName myKeyedList;
  40     private QName myKeyLeaf;
  41     private QName myLeafInList1;
  42     private QName myLeafInList2;
  43     private QName myOrderedList;
  44     private QName myKeyLeafInOrderedList;
  45     private QName myLeafInOrderedList1;
  46     private QName myLeafInOrderedList2;
  47     private QName myUnkeyedList;
  48     private QName myLeafInUnkeyedList;
  49     private QName myLeaf1;
  50     private QName myLeafList;
  51     private QName myOrderedLeafList;
  52
  53     private QName myContainer2;
  54     private QName innerContainer;
  55     private QName myLeaf2;
  56     private QName myLeaf3;
  57     private QName myChoice;
  58     private QName myLeafInCase2;
  59
  60     private QName myContainer3;
  61     private QName myDoublyKeyedList;
  62     private QName myFirstKeyLeaf;
  63     private QName mySecondKeyLeaf;
  64     private QName myLeafInList3;
  65
  66     @BeforeEach
  67     void setup() {
  68         foobarModule = QNameModule.create(XMLNamespace.of("foobar-namespace"), Revision.of("2016-09-19"));
  69
  70         outerContainer = QName.create(foobarModule, "outer-container");
  71
  72         myContainer1 = QName.create(foobarModule, "my-container-1");
  73         myKeyedList = QName.create(foobarModule, "my-keyed-list");
  74         myKeyLeaf = QName.create(foobarModule, "my-key-leaf");
  75         myLeafInList1 = QName.create(foobarModule, "my-leaf-in-list-1");
  76         myLeafInList2 = QName.create(foobarModule, "my-leaf-in-list-2");
  77         myOrderedList = QName.create(foobarModule, "my-ordered-list");
  78         myKeyLeafInOrderedList = QName.create(foobarModule, "my-key-leaf-in-ordered-list");
  79         myLeafInOrderedList1 = QName.create(foobarModule, "my-leaf-in-ordered-list-1");
  80         myLeafInOrderedList2 = QName.create(foobarModule, "my-leaf-in-ordered-list-2");
  81         myUnkeyedList = QName.create(foobarModule, "my-unkeyed-list");
  82         myLeafInUnkeyedList = QName.create(foobarModule, "my-leaf-in-unkeyed-list");
  83         myLeaf1 = QName.create(foobarModule, "my-leaf-1");
  84         myLeafList = QName.create(foobarModule, "my-leaf-list");
  85         myOrderedLeafList = QName.create(foobarModule, "my-ordered-leaf-list");
  86
  87         myContainer2 = QName.create(foobarModule, "my-container-2");
  88         innerContainer = QName.create(foobarModule, "inner-container");
  89         myLeaf2 = QName.create(foobarModule, "my-leaf-2");
  90         myLeaf3 = QName.create(foobarModule, "my-leaf-3");
  91         myChoice = QName.create(foobarModule, "my-choice");
  92         myLeafInCase2 = QName.create(foobarModule, "my-leaf-in-case-2");
  93
  94         myContainer3 = QName.create(foobarModule, "my-container-3");
  95         myDoublyKeyedList = QName.create(foobarModule, "my-doubly-keyed-list");
  96         myFirstKeyLeaf = QName.create(foobarModule, "my-first-key-leaf");
  97         mySecondKeyLeaf = QName.create(foobarModule, "my-second-key-leaf");
  98         myLeafInList3 = QName.create(foobarModule, "my-leaf-in-list-3");
  99     }
 100
 101     @ParameterizedTest(name = "{0}")
 102     @ArgumentsSource(TestFactories.class)
 103     void testWrite(final String factoryMode, final XMLOutputFactory factory) throws Exception {
 104         final var doc = loadDocument("/foobar.xml");
 105         final var domResult = new DOMResult(UntrustedXML.newDocumentBuilder().newDocument());
 106         final var xmlStreamWriter = factory.createXMLStreamWriter(domResult);
 107         final var schemalessXmlNormalizedNodeStreamWriter =
 108                 XMLStreamNormalizedNodeStreamWriter.createSchemaless(xmlStreamWriter);
 109         final var normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(schemalessXmlNormalizedNodeStreamWriter);
 110
 111         normalizedNodeWriter.write(buildOuterContainerNode());
 112
 113         XMLUnit.setIgnoreWhitespace(true);
 114         XMLUnit.setNormalize(true);
 115
 116         final String expectedXml = toString(doc.getDocumentElement());
 117         final String serializedXml = toString(domResult.getNode());
 118         final Diff diff = new Diff(expectedXml, serializedXml);
 119         diff.overrideDifferenceListener(new IgnoreTextAndAttributeValuesDifferenceListener());
 120
 121         XMLAssert.assertXMLEqual(diff, true);
 122     }
 123
 124     private ContainerNode buildOuterContainerNode() {
 125         return Builders.containerBuilder()
 126             .withNodeIdentifier(new NodeIdentifier(outerContainer))
 127             .withChild(Builders.containerBuilder()
 128                 .withNodeIdentifier(new NodeIdentifier(myContainer1))
 129                 .withChild(Builders.mapBuilder()
 130                     .withNodeIdentifier(new NodeIdentifier(myKeyedList))
 131                     .withChild(Builders.mapEntryBuilder()
 132                         .withNodeIdentifier(NodeIdentifierWithPredicates.of(myKeyedList, myKeyLeaf, "listkeyvalue1"))
 133                         .withChild(ImmutableNodes.leafNode(myLeafInList1, "listleafvalue1"))
 134                         .withChild(ImmutableNodes.leafNode(myLeafInList2, "listleafvalue2"))
 135                         .build())
 136                     .withChild(Builders.mapEntryBuilder()
 137                         .withNodeIdentifier(NodeIdentifierWithPredicates.of(myKeyedList, myKeyLeaf, "listkeyvalue2"))
 138                         .withChild(ImmutableNodes.leafNode(myLeafInList1, "listleafvalue12"))
 139                         .withChild(ImmutableNodes.leafNode(myLeafInList2, "listleafvalue22"))
 140                         .build())
 141                     .build())
 142                 .withChild(Builders.orderedMapBuilder()
 143                     .withNodeIdentifier(new NodeIdentifier(myOrderedList))
 144                     .withChild(Builders.mapEntryBuilder()
 145                         .withNodeIdentifier(
 146                             NodeIdentifierWithPredicates.of(myOrderedList, myKeyLeafInOrderedList, "olistkeyvalue1"))
 147                         .withChild(ImmutableNodes.leafNode(myLeafInOrderedList1, "olistleafvalue1"))
 148                         .withChild(ImmutableNodes.leafNode(myLeafInOrderedList2, "olistleafvalue2"))
 149                         .build())
 150                     .withChild(Builders.mapEntryBuilder()
 151                         .withNodeIdentifier(
 152                             NodeIdentifierWithPredicates.of(myOrderedList, myKeyLeafInOrderedList, "olistkeyvalue2"))
 153                         .withChild(ImmutableNodes.leafNode(myLeafInOrderedList1, "olistleafvalue12"))
 154                         .withChild(ImmutableNodes.leafNode(myLeafInOrderedList2, "olistleafvalue22"))
 155                         .build())
 156                     .build())
 157                 .withChild(Builders.unkeyedListBuilder()
 158                     .withNodeIdentifier(new NodeIdentifier(myUnkeyedList))
 159                     .withChild(Builders.unkeyedListEntryBuilder()
 160                         .withNodeIdentifier(new NodeIdentifier(myUnkeyedList))
 161                         .withChild(ImmutableNodes.leafNode(myLeafInUnkeyedList, "foo"))
 162                         .build())
 163                     .build())
 164                 .withChild(ImmutableNodes.leafNode(myLeaf1, "value1"))
 165                 .withChild(Builders.leafSetBuilder()
 166                     .withNodeIdentifier(new NodeIdentifier(myLeafList))
 167                     .withChild(Builders.leafSetEntryBuilder()
 168                         .withNodeIdentifier(new NodeWithValue<>(myLeafList, "lflvalue1"))
 169                         .withValue("lflvalue1")
 170                         .build())
 171                     .withChild(Builders.leafSetEntryBuilder()
 172                         .withNodeIdentifier(new NodeWithValue<>(myLeafList, "lflvalue2"))
 173                         .withValue("lflvalue2")
 174                         .build())
 175                     .build())
 176                 .withChild(Builders.orderedLeafSetBuilder()
 177                     .withNodeIdentifier(new NodeIdentifier(myOrderedLeafList))
 178                     .withChild(Builders.leafSetEntryBuilder()
 179                         .withNodeIdentifier(new NodeWithValue<>(myOrderedLeafList, "olflvalue1"))
 180                         .withValue("olflvalue1")
 181                         .build())
 182                     .withChild(Builders.leafSetEntryBuilder()
 183                         .withNodeIdentifier(new NodeWithValue<>(myOrderedLeafList, "olflvalue2"))
 184                         .withValue("olflvalue2")
 185                         .build())
 186                     .build())
 187                 .build())
 188             .withChild(Builders.containerBuilder().withNodeIdentifier(
 189                 new NodeIdentifier(myContainer2))
 190                 .withChild(Builders.containerBuilder()
 191                     .withNodeIdentifier(new NodeIdentifier(innerContainer))
 192                     .withChild(ImmutableNodes.leafNode(myLeaf2, "value2"))
 193                     .build())
 194                 .withChild(ImmutableNodes.leafNode(myLeaf3, "value3"))
 195                 .withChild(Builders.choiceBuilder()
 196                     .withNodeIdentifier(new NodeIdentifier(myChoice))
 197                     .withChild(ImmutableNodes.leafNode(myLeafInCase2, "case2value"))
 198                     .build())
 199 //                .withChild(Builders.anyXmlBuilder()
 200 //                    .withNodeIdentifier(new NodeIdentifier(myAnyxml))
 201 //                    .withValue(anyxmlDomSource)
 202 //                    .build())
 203                 .build())
 204             .withChild(Builders.containerBuilder()
 205                 .withNodeIdentifier(new NodeIdentifier(myContainer3))
 206                 .withChild(Builders.mapBuilder()
 207                     .withNodeIdentifier(new NodeIdentifier(myDoublyKeyedList))
 208                     .withChild(Builders.mapEntryBuilder()
 209                         .withNodeIdentifier(NodeIdentifierWithPredicates.of(myDoublyKeyedList,
 210                             Map.of(myFirstKeyLeaf, "listkeyvalue1", mySecondKeyLeaf, "listkeyvalue2")))
 211                         .withChild(ImmutableNodes.leafNode(myLeafInList3, "listleafvalue1"))
 212                         .build())
 213                     .build())
 214                 .build())
 215             .build();
 216     }
 217 }