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