04e6169b68fcb2f60bfab42452b111b51ca44a9c
[yangtools.git] / 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
9 package org.opendaylight.yangtools.yang.data.codec.xml;
10
11 import static java.util.Objects.requireNonNull;
12
13 import com.google.common.collect.ImmutableSet;
14 import java.io.IOException;
15 import java.io.InputStream;
16 import java.io.StringWriter;
17 import java.util.ArrayList;
18 import java.util.Collection;
19 import java.util.HashMap;
20 import java.util.List;
21 import java.util.Map;
22 import javax.xml.stream.XMLOutputFactory;
23 import javax.xml.stream.XMLStreamException;
24 import javax.xml.stream.XMLStreamWriter;
25 import javax.xml.transform.OutputKeys;
26 import javax.xml.transform.Transformer;
27 import javax.xml.transform.TransformerException;
28 import javax.xml.transform.TransformerFactory;
29 import javax.xml.transform.TransformerFactoryConfigurationError;
30 import javax.xml.transform.dom.DOMResult;
31 import javax.xml.transform.dom.DOMSource;
32 import javax.xml.transform.stream.StreamResult;
33 import org.custommonkey.xmlunit.Diff;
34 import org.custommonkey.xmlunit.DifferenceListener;
35 import org.custommonkey.xmlunit.IgnoreTextAndAttributeValuesDifferenceListener;
36 import org.custommonkey.xmlunit.XMLAssert;
37 import org.custommonkey.xmlunit.XMLUnit;
38 import org.junit.Before;
39 import org.junit.Test;
40 import org.junit.runner.RunWith;
41 import org.junit.runners.Parameterized;
42 import org.opendaylight.yangtools.util.xml.UntrustedXML;
43 import org.opendaylight.yangtools.yang.common.QName;
44 import org.opendaylight.yangtools.yang.common.QNameModule;
45 import org.opendaylight.yangtools.yang.common.Revision;
46 import org.opendaylight.yangtools.yang.common.XMLNamespace;
47 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
48 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
49 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
50 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
51 import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
52 import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
53 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
54 import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
55 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
56 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
57 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
58 import org.opendaylight.yangtools.yang.data.api.schema.SystemLeafSetNode;
59 import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
60 import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
61 import org.opendaylight.yangtools.yang.data.api.schema.UserLeafSetNode;
62 import org.opendaylight.yangtools.yang.data.api.schema.UserMapNode;
63 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
64 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeWriter;
65 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
66 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
67 import org.w3c.dom.Document;
68 import org.w3c.dom.Node;
69 import org.xml.sax.SAXException;
70
71 @RunWith(Parameterized.class)
72 public class SchemalessXMLStreamNormalizedNodeStreamWriterTest {
73     @Parameterized.Parameters(name = "{0}")
74     public static Collection<Object[]> data() {
75         return TestFactories.junitParameters();
76     }
77
78     private final XMLOutputFactory factory;
79
80     private QNameModule foobarModule;
81
82     private QName outerContainer;
83
84     private QName myContainer1;
85     private QName myKeyedList;
86     private QName myKeyLeaf;
87     private QName myLeafInList1;
88     private QName myLeafInList2;
89     private QName myOrderedList;
90     private QName myKeyLeafInOrderedList;
91     private QName myLeafInOrderedList1;
92     private QName myLeafInOrderedList2;
93     private QName myUnkeyedList;
94     private QName myLeafInUnkeyedList;
95     private QName myLeaf1;
96     private QName myLeafList;
97     private QName myOrderedLeafList;
98
99     private QName myContainer2;
100     private QName innerContainer;
101     private QName myLeaf2;
102     private QName myLeaf3;
103     private QName myChoice;
104     private QName myLeafInCase2;
105     private QName myAnyxml;
106
107     private QName myContainer3;
108     private QName myDoublyKeyedList;
109     private QName myFirstKeyLeaf;
110     private QName mySecondKeyLeaf;
111     private QName myLeafInList3;
112
113     private DOMSource anyxmlDomSource;
114
115     public SchemalessXMLStreamNormalizedNodeStreamWriterTest(final String factoryMode, final XMLOutputFactory factory) {
116         this.factory = factory;
117     }
118
119     @Before
120     public void setup() {
121         foobarModule = QNameModule.create(XMLNamespace.of("foobar-namespace"), Revision.of("2016-09-19"));
122
123         outerContainer = QName.create(foobarModule, "outer-container");
124
125         myContainer1 = QName.create(foobarModule, "my-container-1");
126         myKeyedList = QName.create(foobarModule, "my-keyed-list");
127         myKeyLeaf = QName.create(foobarModule, "my-key-leaf");
128         myLeafInList1 = QName.create(foobarModule, "my-leaf-in-list-1");
129         myLeafInList2 = QName.create(foobarModule, "my-leaf-in-list-2");
130         myOrderedList = QName.create(foobarModule, "my-ordered-list");
131         myKeyLeafInOrderedList = QName.create(foobarModule, "my-key-leaf-in-ordered-list");
132         myLeafInOrderedList1 = QName.create(foobarModule, "my-leaf-in-ordered-list-1");
133         myLeafInOrderedList2 = QName.create(foobarModule, "my-leaf-in-ordered-list-2");
134         myUnkeyedList = QName.create(foobarModule, "my-unkeyed-list");
135         myLeafInUnkeyedList = QName.create(foobarModule, "my-leaf-in-unkeyed-list");
136         myLeaf1 = QName.create(foobarModule, "my-leaf-1");
137         myLeafList = QName.create(foobarModule, "my-leaf-list");
138         myOrderedLeafList = QName.create(foobarModule, "my-ordered-leaf-list");
139
140         myContainer2 = QName.create(foobarModule, "my-container-2");
141         innerContainer = QName.create(foobarModule, "inner-container");
142         myLeaf2 = QName.create(foobarModule, "my-leaf-2");
143         myLeaf3 = QName.create(foobarModule, "my-leaf-3");
144         myChoice = QName.create(foobarModule, "my-choice");
145         myLeafInCase2 = QName.create(foobarModule, "my-leaf-in-case-2");
146         myAnyxml = QName.create(foobarModule, "my-anyxml");
147
148         myContainer3 = QName.create(foobarModule, "my-container-3");
149         myDoublyKeyedList = QName.create(foobarModule, "my-doubly-keyed-list");
150         myFirstKeyLeaf = QName.create(foobarModule, "my-first-key-leaf");
151         mySecondKeyLeaf = QName.create(foobarModule, "my-second-key-leaf");
152         myLeafInList3 = QName.create(foobarModule, "my-leaf-in-list-3");
153
154         anyxmlDomSource = new DOMSource();
155     }
156
157     @Test
158     public void testWrite() throws XMLStreamException, IOException, SAXException {
159         final Document doc = loadDocument("/foobar.xml");
160
161         final DOMResult domResult = new DOMResult(UntrustedXML.newDocumentBuilder().newDocument());
162
163         final XMLStreamWriter xmlStreamWriter = factory.createXMLStreamWriter(domResult);
164
165         final NormalizedNodeStreamWriter schemalessXmlNormalizedNodeStreamWriter =
166                 XMLStreamNormalizedNodeStreamWriter.createSchemaless(xmlStreamWriter);
167
168         final NormalizedNodeWriter normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(
169                 schemalessXmlNormalizedNodeStreamWriter);
170
171         normalizedNodeWriter.write(buildOuterContainerNode());
172
173         XMLUnit.setIgnoreWhitespace(true);
174         XMLUnit.setNormalize(true);
175
176         final String expectedXml = toString(doc.getDocumentElement());
177         final String serializedXml = toString(domResult.getNode());
178         final Diff diff = new Diff(expectedXml, serializedXml);
179
180         final DifferenceListener differenceListener = new IgnoreTextAndAttributeValuesDifferenceListener();
181         diff.overrideDifferenceListener(differenceListener);
182
183         XMLAssert.assertXMLEqual(diff, true);
184     }
185
186     private NormalizedNode buildOuterContainerNode() {
187         // my-container-1
188         MapNode myKeyedListNode = Builders.mapBuilder().withNodeIdentifier(new NodeIdentifier(myKeyedList))
189                 .withChild(Builders.mapEntryBuilder().withNodeIdentifier(
190                         NodeIdentifierWithPredicates.of(myKeyedList, myKeyLeaf, "listkeyvalue1"))
191                         .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInList1))
192                                 .withValue("listleafvalue1").build())
193                         .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInList2))
194                                 .withValue("listleafvalue2").build()).build())
195                 .withChild(Builders.mapEntryBuilder().withNodeIdentifier(
196                         NodeIdentifierWithPredicates.of(myKeyedList, myKeyLeaf, "listkeyvalue2"))
197                         .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInList1))
198                                 .withValue("listleafvalue12").build())
199                         .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInList2))
200                                 .withValue("listleafvalue22").build()).build()).build();
201
202         UserMapNode myOrderedListNode = Builders.orderedMapBuilder().withNodeIdentifier(
203                 new NodeIdentifier(myOrderedList)).withChild(Builders.mapEntryBuilder().withNodeIdentifier(
204                         NodeIdentifierWithPredicates.of(myOrderedList, myKeyLeafInOrderedList, "olistkeyvalue1"))
205                         .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInOrderedList1))
206                                 .withValue("olistleafvalue1").build())
207                         .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInOrderedList2))
208                                 .withValue("olistleafvalue2").build()).build())
209                 .withChild(Builders.mapEntryBuilder().withNodeIdentifier(
210                         NodeIdentifierWithPredicates.of(myOrderedList, myKeyLeafInOrderedList, "olistkeyvalue2"))
211                         .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInOrderedList1))
212                                 .withValue("olistleafvalue12").build())
213                         .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInOrderedList2))
214                                 .withValue("olistleafvalue22").build()).build()).build();
215
216         final UnkeyedListEntryNode unkeyedListEntry = Builders.unkeyedListEntryBuilder()
217                 .withNodeIdentifier(new NodeIdentifier(myUnkeyedList))
218                 .withChild(ImmutableNodes.leafNode(myLeafInUnkeyedList, "foo")).build();
219
220         final List<UnkeyedListEntryNode> unkeyedListEntries = new ArrayList<>();
221         unkeyedListEntries.add(unkeyedListEntry);
222
223         UnkeyedListNode myUnkeyedListNode = Builders.unkeyedListBuilder().withNodeIdentifier(
224                 new NodeIdentifier(myUnkeyedList))
225                 .withValue(unkeyedListEntries).build();
226
227         LeafNode<?> myLeaf1Node = ImmutableNodes.leafNode(myLeaf1, "value1");
228
229         SystemLeafSetNode<?> myLeafListNode = Builders.leafSetBuilder()
230                 .withNodeIdentifier(new NodeIdentifier(myLeafList))
231                 .withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(
232                         new NodeWithValue<>(myLeafList, "lflvalue1")).withValue("lflvalue1").build())
233                 .withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(
234                         new NodeWithValue<>(myLeafList, "lflvalue2")).withValue("lflvalue2").build()).build();
235
236         UserLeafSetNode<?> myOrderedLeafListNode = Builders.orderedLeafSetBuilder()
237                 .withNodeIdentifier(new NodeIdentifier(myOrderedLeafList))
238                 .withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(
239                         new NodeWithValue<>(myOrderedLeafList, "olflvalue1")).withValue("olflvalue1").build())
240                 .withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(
241                         new NodeWithValue<>(myOrderedLeafList, "olflvalue2")).withValue("olflvalue2").build()).build();
242
243         ContainerNode myContainer1Node = Builders.containerBuilder().withNodeIdentifier(
244                 new NodeIdentifier(myContainer1))
245                 .withChild(myKeyedListNode)
246                 .withChild(myOrderedListNode)
247                 .withChild(myUnkeyedListNode)
248                 .withChild(myLeaf1Node)
249                 .withChild(myLeafListNode)
250                 .withChild(myOrderedLeafListNode)
251                 .build();
252
253         // my-container-2
254         ContainerNode innerContainerNode = Builders.containerBuilder().withNodeIdentifier(
255                 new NodeIdentifier(innerContainer))
256                 .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeaf2))
257                         .withValue("value2").build()).build();
258
259         LeafNode<?> myLeaf3Node = Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeaf3))
260                 .withValue("value3").build();
261
262         ChoiceNode myChoiceNode = Builders.choiceBuilder().withNodeIdentifier(new NodeIdentifier(myChoice))
263                 .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInCase2))
264                         .withValue("case2value").build()).build();
265
266         DOMSourceAnyxmlNode myAnyxmlNode = Builders.anyXmlBuilder().withNodeIdentifier(new NodeIdentifier(myAnyxml))
267                 .withValue(anyxmlDomSource).build();
268
269         ContainerNode myContainer2Node = Builders.containerBuilder().withNodeIdentifier(
270                 new NodeIdentifier(myContainer2))
271                 .withChild(innerContainerNode)
272                 .withChild(myLeaf3Node)
273                 .withChild(myChoiceNode).build();
274                 //.withChild(myAnyxmlNode).build();
275
276         // my-container-3
277         Map<QName, Object> keys = new HashMap<>();
278         keys.put(myFirstKeyLeaf, "listkeyvalue1");
279         keys.put(mySecondKeyLeaf, "listkeyvalue2");
280
281         MapNode myDoublyKeyedListNode = Builders.mapBuilder().withNodeIdentifier(new NodeIdentifier(myDoublyKeyedList))
282                 .withChild(Builders.mapEntryBuilder().withNodeIdentifier(
283                         NodeIdentifierWithPredicates.of(myDoublyKeyedList, keys))
284                         .withChild(Builders.leafBuilder().withNodeIdentifier(
285                                 new NodeIdentifier(myLeafInList3)).withValue("listleafvalue1").build()).build())
286                 .build();
287
288         AugmentationNode myDoublyKeyedListAugNode = Builders.augmentationBuilder().withNodeIdentifier(
289                 new AugmentationIdentifier(ImmutableSet.of(myDoublyKeyedList)))
290                 .withChild(myDoublyKeyedListNode).build();
291
292         ContainerNode myContainer3Node = Builders.containerBuilder().withNodeIdentifier(
293                 new NodeIdentifier(myContainer3))
294                 .withChild(myDoublyKeyedListAugNode).build();
295
296         AugmentationNode myContainer3AugNode = Builders.augmentationBuilder().withNodeIdentifier(
297                 new AugmentationIdentifier(ImmutableSet.of(myContainer3)))
298                 .withChild(myContainer3Node).build();
299
300         ContainerNode outerContainerNode = Builders.containerBuilder().withNodeIdentifier(
301                 new NodeIdentifier(outerContainer))
302                 .withChild(myContainer1Node)
303                 .withChild(myContainer2Node)
304                 .withChild(myContainer3AugNode).build();
305
306         return outerContainerNode;
307     }
308
309     private static Document loadDocument(final String xmlPath) throws IOException, SAXException {
310         final InputStream resourceAsStream = SchemalessXMLStreamNormalizedNodeStreamWriterTest.class
311             .getResourceAsStream(xmlPath);
312         return requireNonNull(readXmlToDocument(resourceAsStream));
313     }
314
315     private static Document readXmlToDocument(final InputStream xmlContent) throws IOException, SAXException {
316         final Document doc = UntrustedXML.newDocumentBuilder().parse(xmlContent);
317         doc.getDocumentElement().normalize();
318         return doc;
319     }
320
321     private static String toString(final Node xml) {
322         try {
323             final Transformer transformer = TransformerFactory.newInstance().newTransformer();
324             transformer.setOutputProperty(OutputKeys.INDENT, "yes");
325             transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4");
326
327             final StreamResult result = new StreamResult(new StringWriter());
328             final DOMSource source = new DOMSource(xml);
329             transformer.transform(source, result);
330
331             return result.getWriter().toString();
332         } catch (IllegalArgumentException | TransformerFactoryConfigurationError | TransformerException e) {
333             throw new RuntimeException("Unable to serialize xml element " + xml, e);
334         }
335     }
336 }