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