codec/yang-data-codec-xml/src/test/java/org/opendaylight/yangtools/yang/data/codec/xml/SchemaOrderedNormalizedNodeWriterTest.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 static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertFalse;
  12
  13 import java.io.StringWriter;
  14 import java.util.ArrayList;
  15 import java.util.Collection;
  16 import javax.xml.stream.XMLOutputFactory;
  17 import javax.xml.stream.XMLStreamWriter;
  18 import org.junit.Test;
  19 import org.junit.runner.RunWith;
  20 import org.junit.runners.Parameterized;
  21 import org.opendaylight.yangtools.yang.common.QName;
  22 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  23 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
  24 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
  25 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
  26 import org.opendaylight.yangtools.yang.data.impl.schema.SchemaOrderedNormalizedNodeWriter;
  27 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
  28 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
  29 import org.xmlunit.builder.DiffBuilder;
  30
  31 @RunWith(Parameterized.class)
  32 public class SchemaOrderedNormalizedNodeWriterTest {
  33     @Parameterized.Parameters(name = "{0}")
  34     public static Collection<Object[]> data() {
  35         return TestFactories.junitParameters();
  36     }
  37
  38     private static final String FOO_NAMESPACE = "foo";
  39     private static final String RULE_NODE = "rule";
  40     private static final String NAME_NODE = "name";
  41     private static final String POLICY_NODE = "policy";
  42     private static final String ORDER_NAMESPACE = "order";
  43
  44     private final XMLOutputFactory factory;
  45
  46     public SchemaOrderedNormalizedNodeWriterTest(final String factoryMode, final XMLOutputFactory factory) {
  47         this.factory = factory;
  48     }
  49
  50     @Test
  51     public void testWrite() throws Exception {
  52         final var stringWriter = new StringWriter();
  53         final var xmlStreamWriter = factory.createXMLStreamWriter(stringWriter);
  54
  55         final var schemaContext = YangParserTestUtils.parseYang("""
  56             module foo {
  57               namespace "foo";
  58               prefix "foo";
  59               revision "2016-02-17";
  60
  61               container root {
  62                 list policy {
  63                   key name;
  64                   leaf name {
  65                     type string;
  66                   }
  67                   list rule {
  68                     key name;
  69                     leaf name {
  70                       type string;
  71                     }
  72                   }
  73                 }
  74               }
  75             }""");
  76         var writer = XMLStreamNormalizedNodeStreamWriter.create(xmlStreamWriter, schemaContext);
  77
  78         try (var nnw = new SchemaOrderedNormalizedNodeWriter(writer, schemaContext)) {
  79
  80             final var rule1Names = new ArrayList<MapEntryNode>();
  81             rule1Names.add(ImmutableNodes.mapEntry(createQName(FOO_NAMESPACE, RULE_NODE),
  82                 createQName(FOO_NAMESPACE, NAME_NODE), "rule1"));
  83             rule1Names.add(ImmutableNodes.mapEntry(createQName(FOO_NAMESPACE, RULE_NODE),
  84                 createQName(FOO_NAMESPACE, NAME_NODE), "rule2"));
  85
  86             final var rule2Names = new ArrayList<MapEntryNode>();
  87             rule1Names.add(ImmutableNodes.mapEntry(createQName(FOO_NAMESPACE, RULE_NODE),
  88                 createQName(FOO_NAMESPACE, NAME_NODE), "rule3"));
  89             rule1Names.add(ImmutableNodes.mapEntry(createQName(FOO_NAMESPACE, RULE_NODE),
  90                 createQName(FOO_NAMESPACE, NAME_NODE), "rule4"));
  91
  92             final var rules1 = Builders.orderedMapBuilder()
  93                     .withNodeIdentifier(getNodeIdentifier(FOO_NAMESPACE, RULE_NODE))
  94                     .withValue(rule1Names)
  95                     .build();
  96             final var rules2 = Builders.orderedMapBuilder()
  97                     .withNodeIdentifier(getNodeIdentifier(FOO_NAMESPACE, RULE_NODE))
  98                     .withValue(rule2Names)
  99                     .build();
 100
 101             final var policyNodes = new ArrayList<MapEntryNode>();
 102
 103
 104             final var pn1 = ImmutableNodes.mapEntryBuilder(createQName(FOO_NAMESPACE, POLICY_NODE),
 105                         createQName(FOO_NAMESPACE, NAME_NODE), "policy1")
 106                     .withChild(rules1)
 107                     .build();
 108             final var pn2 = ImmutableNodes.mapEntryBuilder(createQName(FOO_NAMESPACE, POLICY_NODE),
 109                         createQName(FOO_NAMESPACE, NAME_NODE), "policy2")
 110                     .withChild(rules2)
 111                     .build();
 112             policyNodes.add(pn1);
 113             policyNodes.add(pn2);
 114
 115             final var policy = Builders.orderedMapBuilder()
 116                     .withNodeIdentifier(getNodeIdentifier(FOO_NAMESPACE, POLICY_NODE))
 117                     .withValue(policyNodes)
 118                     .build();
 119             final var root = Builders.containerBuilder()
 120                     .withNodeIdentifier(getNodeIdentifier(FOO_NAMESPACE, "root"))
 121                     .withChild(policy).build();
 122             nnw.write(root);
 123         }
 124
 125         final var diff = DiffBuilder.compare(stringWriter.toString())
 126             .withTest("""
 127                 <root xmlns="foo">
 128                     <policy>
 129                         <name>policy1</name>
 130                         <rule>
 131                             <name>rule1</name>
 132                         </rule>
 133                         <rule>
 134                             <name>rule2</name>
 135                         </rule>
 136                         <rule>
 137                             <name>rule3</name>
 138                         </rule>
 139                         <rule>
 140                             <name>rule4</name>
 141                         </rule>
 142                     </policy>
 143                     <policy>
 144                         <name>policy2</name>
 145                     </policy>
 146                 </root>""")
 147             .ignoreWhitespace()
 148             .checkForIdentical()
 149             .build();
 150         assertFalse(diff.toString(), diff.hasDifferences());
 151     }
 152
 153     @Test
 154     public void testWriteOrder() throws Exception {
 155         final StringWriter stringWriter = new StringWriter();
 156         final XMLStreamWriter xmlStreamWriter = factory.createXMLStreamWriter(stringWriter);
 157         EffectiveModelContext schemaContext = YangParserTestUtils.parseYang("""
 158             module order {
 159               namespace "order";
 160               prefix "order";
 161               revision "2016-02-17";
 162
 163               container root {
 164                 leaf id {
 165                   type string;
 166                 }
 167                 container cont {
 168                   leaf content {
 169                     type string;
 170                   }
 171                 }
 172               }
 173             }""");
 174         var writer = XMLStreamNormalizedNodeStreamWriter.create(xmlStreamWriter, schemaContext);
 175
 176         try (var nnw = new SchemaOrderedNormalizedNodeWriter(writer, schemaContext)) {
 177
 178             final var cont = Builders.containerBuilder()
 179                     .withNodeIdentifier(getNodeIdentifier(ORDER_NAMESPACE, "cont"))
 180                     .withChild(ImmutableNodes.leafNode(createQName(ORDER_NAMESPACE, "content"), "content1"))
 181                     .build();
 182
 183             final var root = Builders.containerBuilder()
 184                     .withNodeIdentifier(getNodeIdentifier(ORDER_NAMESPACE, "root"))
 185                     .withChild(cont)
 186                     .withChild(ImmutableNodes.leafNode(createQName(ORDER_NAMESPACE, "id"), "id1"))
 187                     .build();
 188
 189             nnw.write(root);
 190         }
 191
 192         assertEquals("""
 193             <root xmlns="order"><id>id1</id><cont><content>content1</content></cont></root>""",
 194             stringWriter.toString());
 195     }
 196
 197     private static NodeIdentifier getNodeIdentifier(final String ns, final String name) {
 198         return NodeIdentifier.create(createQName(ns, name));
 199     }
 200
 201     private static QName createQName(final String ns, final String name) {
 202         return QName.create(ns, "2016-02-17", name);
 203     }
 204 }