opendaylight/md-sal/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/cnsn/to/xml/test/CnSnToXmlTest.java

   1 /*
   2  * Copyright (c) 2014 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.controller.sal.restconf.impl.cnsn.to.xml.test;
   9
  10 import static org.junit.Assert.assertNotNull;
  11 import static org.junit.Assert.assertTrue;
  12
  13 import java.io.IOException;
  14
  15 import javax.ws.rs.WebApplicationException;
  16 import javax.xml.transform.TransformerFactoryConfigurationError;
  17
  18 import org.junit.BeforeClass;
  19 import org.junit.Test;
  20 import org.opendaylight.controller.sal.rest.impl.StructuredDataToXmlProvider;
  21 import org.opendaylight.controller.sal.restconf.impl.test.TestUtils;
  22 import org.opendaylight.controller.sal.restconf.impl.test.YangAndXmlAndDataSchemaLoader;
  23 import org.opendaylight.yangtools.yang.data.api.CompositeNode;
  24 import org.opendaylight.yangtools.yang.data.api.ModifyAction;
  25 import org.opendaylight.yangtools.yang.data.api.MutableCompositeNode;
  26 import org.opendaylight.yangtools.yang.data.api.MutableSimpleNode;
  27 import org.opendaylight.yangtools.yang.data.impl.NodeFactory;
  28 import org.opendaylight.yangtools.yang.data.impl.codec.TypeDefinitionAwareCodec;
  29
  30 /**
  31  *
  32  * CnSn = Composite node and Simple node data structure Class contains test of
  33  * serializing simple nodes data values according data types from YANG schema to
  34  * XML file
  35  *
  36  */
  37 public class CnSnToXmlTest extends YangAndXmlAndDataSchemaLoader {
  38     @BeforeClass
  39     public static void initialization() {
  40         dataLoad("/cnsn-to-xml/yang", 2, "basic-module", "cont");
  41     }
  42
  43     @Test
  44     public void snAsYangIdentityrefToXMLTest() {
  45         serializeToXml(prepareIdentityrefData(null, true), "<lf11 xmlns:x=\"referenced:module\">x:iden</lf11>");
  46     }
  47
  48     @Test
  49     public void snAsYangIdentityrefWithQNamePrefixToXMLTest() {
  50         serializeToXml(prepareIdentityrefData("prefix", true),
  51                 "<lf11 xmlns:prefix=\"referenced:module\">prefix:iden</lf11>");
  52     }
  53
  54     @Test
  55     public void snAsYangIdentityrefWithPrefixToXMLTest() {
  56         serializeToXml(prepareIdentityrefData("prefix", false), "<lf11>no qname value</lf11>");
  57     }
  58
  59     @Test
  60     public void snAsYangLeafrefWithPrefixToXMLTest() {
  61         serializeToXml(prepareLeafrefData(), "<lfBoolean>true</lfBoolean>", "<lfLfref>true</lfLfref>");
  62     }
  63
  64
  65     @Test
  66     public void snAsYangStringToXmlTest() {
  67         serializeToXml(
  68                 prepareCnStructForYangData(TypeDefinitionAwareCodec.STRING_DEFAULT_CODEC.deserialize("lfStr value"),
  69                         "lfStr"), "<lfStr>lfStr value</lfStr>");
  70     }
  71
  72     @Test
  73     public void snAsYangInt8ToXmlTest() {
  74         String elName = "lfInt8";
  75         serializeToXml(
  76                 prepareCnStructForYangData(TypeDefinitionAwareCodec.INT8_DEFAULT_CODEC.deserialize("14"), elName), "<"
  77                         + elName + ">14</" + elName + ">");
  78     }
  79
  80     @Test
  81     public void snAsYangInt16ToXmlTest() {
  82         String elName = "lfInt16";
  83         serializeToXml(
  84                 prepareCnStructForYangData(TypeDefinitionAwareCodec.INT16_DEFAULT_CODEC.deserialize("3000"), elName),
  85                 "<" + elName + ">3000</" + elName + ">");
  86     }
  87
  88     @Test
  89     public void snAsYangInt32ToXmlTest() {
  90         String elName = "lfInt32";
  91         serializeToXml(
  92                 prepareCnStructForYangData(TypeDefinitionAwareCodec.INT32_DEFAULT_CODEC.deserialize("201234"), elName),
  93                 "<" + elName + ">201234</" + elName + ">");
  94     }
  95
  96     @Test
  97     public void snAsYangInt64ToXmlTest() {
  98         String elName = "lfInt64";
  99         serializeToXml(
 100                 prepareCnStructForYangData(TypeDefinitionAwareCodec.INT64_DEFAULT_CODEC.deserialize("5123456789"),
 101                         elName), "<" + elName + ">5123456789</" + elName + ">");
 102     }
 103
 104     @Test
 105     public void snAsYangUint8ToXmlTest() {
 106         String elName = "lfUint8";
 107         serializeToXml(
 108                 prepareCnStructForYangData(TypeDefinitionAwareCodec.UINT8_DEFAULT_CODEC.deserialize("200"), elName),
 109                 "<" + elName + ">200</" + elName + ">");
 110     }
 111
 112     @Test
 113     public void snAsYangUint16ToXmlTest() {
 114         String elName = "lfUint16";
 115         serializeToXml(
 116                 prepareCnStructForYangData(TypeDefinitionAwareCodec.UINT16_DEFAULT_CODEC.deserialize("4000"), elName),
 117                 "<" + elName + ">4000</" + elName + ">");
 118     }
 119
 120     @Test
 121     public void snAsYangUint32ToXmlTest() {
 122         String elName = "lfUint32";
 123         serializeToXml(
 124                 prepareCnStructForYangData(TypeDefinitionAwareCodec.UINT32_DEFAULT_CODEC.deserialize("4123456789"),
 125                         elName), "<" + elName + ">4123456789</" + elName + ">");
 126     }
 127
 128     @Test
 129     public void snAsYangUint64ToXmlTest() {
 130         String elName = "lfUint64";
 131         serializeToXml(
 132                 prepareCnStructForYangData(TypeDefinitionAwareCodec.UINT64_DEFAULT_CODEC.deserialize("5123456789"),
 133                         elName), "<" + elName + ">5123456789</" + elName + ">");
 134     }
 135
 136     @Test
 137     public void snAsYangBinaryToXmlTest() {
 138         String elName = "lfBinary";
 139         serializeToXml(
 140                 prepareCnStructForYangData(
 141                         TypeDefinitionAwareCodec.BINARY_DEFAULT_CODEC
 142                         .deserialize("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567"),
 143                         elName), "<" + elName + ">ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567</"
 144                                 + elName + ">");
 145     }
 146
 147     @Test
 148     public void snAsYangBitsToXmlTest() {
 149         String elName = "lfBits";
 150         serializeToXml(
 151                 prepareCnStructForYangData(TypeDefinitionAwareCodec.BITS_DEFAULT_CODEC.deserialize("one two"), elName),
 152                 "<" + elName + ">one two</" + elName + ">", "<" + elName + ">two one</" + elName + ">");
 153     }
 154
 155     @Test
 156     public void snAsYangEnumerationToXmlTest() {
 157         String elName = "lfEnumeration";
 158         serializeToXml(
 159                 prepareCnStructForYangData(TypeDefinitionAwareCodec.ENUMERATION_DEFAULT_CODEC.deserialize("enum2"),
 160                         elName), "<" + elName + ">enum2</" + elName + ">");
 161     }
 162
 163     @Test
 164     public void snAsYangEmptyToXmlTest() {
 165         String elName = "lfEmpty";
 166         serializeToXml(
 167                 prepareCnStructForYangData(TypeDefinitionAwareCodec.EMPTY_DEFAULT_CODEC.deserialize(null), elName), "<"
 168                         + elName + "/>");
 169     }
 170
 171     @Test
 172     public void snAsYangBooleanToXmlTest() {
 173         String elName = "lfBoolean";
 174         serializeToXml(
 175                 prepareCnStructForYangData(TypeDefinitionAwareCodec.BOOLEAN_DEFAULT_CODEC.deserialize("str"), elName),
 176                 "<" + elName + ">false</" + elName + ">");
 177         serializeToXml(
 178                 prepareCnStructForYangData(TypeDefinitionAwareCodec.BOOLEAN_DEFAULT_CODEC.deserialize("true"), elName),
 179                 "<" + elName + ">true</" + elName + ">");
 180     }
 181
 182     @Test
 183     public void snAsYangUnionToXmlTest() {
 184         String elName = "lfUnion";
 185         String int8 = "15";
 186         serializeToXml(
 187                 prepareCnStructForYangData(TypeDefinitionAwareCodec.UNION_DEFAULT_CODEC.deserialize(int8), elName), "<"
 188                         + elName + ">15</" + elName + ">");
 189
 190         String bits = "first second";
 191         serializeToXml(
 192                 prepareCnStructForYangData(TypeDefinitionAwareCodec.UNION_DEFAULT_CODEC.deserialize(bits), elName), "<"
 193                         + elName + ">first second</" + elName + ">");
 194
 195         String bool = "str";
 196         serializeToXml(
 197                 prepareCnStructForYangData(TypeDefinitionAwareCodec.UNION_DEFAULT_CODEC.deserialize(bool), elName), "<"
 198                         + elName + ">str</" + elName + ">");
 199     }
 200
 201     private void serializeToXml(final CompositeNode compositeNode, final String... xmlRepresentation)
 202             throws TransformerFactoryConfigurationError {
 203         String xmlString = "";
 204         try {
 205             xmlString = TestUtils.writeCompNodeWithSchemaContextToOutput(compositeNode, modules, dataSchemaNode,
 206                     StructuredDataToXmlProvider.INSTANCE);
 207         } catch (WebApplicationException | IOException e) {
 208         }
 209         assertNotNull(xmlString);
 210         boolean containSearchedStr = false;
 211         String strRepresentation = "";
 212         for (String searchedStr : xmlRepresentation) {
 213             if (xmlString.contains(searchedStr)) {
 214                 containSearchedStr = true;
 215                 break;
 216             }
 217             strRepresentation = strRepresentation + "[" + searchedStr + "]";
 218         }
 219         assertTrue("At least one of specified strings " + strRepresentation + " wasn't found.", containSearchedStr);
 220
 221     }
 222
 223     private CompositeNode prepareIdentityrefData(final String prefix, final boolean valueAsQName) {
 224         MutableCompositeNode cont = NodeFactory.createMutableCompositeNode(
 225                 TestUtils.buildQName("cont", "basic:module", "2013-12-2"), null, null, ModifyAction.CREATE, null);
 226         MutableCompositeNode cont1 = NodeFactory.createMutableCompositeNode(
 227                 TestUtils.buildQName("cont1", "basic:module", "2013-12-2"), cont, null, ModifyAction.CREATE, null);
 228         cont.getValue().add(cont1);
 229
 230         Object value = null;
 231         if (valueAsQName) {
 232             value = TestUtils.buildQName("iden", "referenced:module", "2013-12-2", prefix);
 233         } else {
 234             value = "no qname value";
 235         }
 236         MutableSimpleNode<Object> lf11 = NodeFactory.createMutableSimpleNode(
 237                 TestUtils.buildQName("lf11", "basic:module", "2013-12-2"), cont1, value, ModifyAction.CREATE, null);
 238         cont1.getValue().add(lf11);
 239         cont1.init();
 240         cont.init();
 241
 242         return cont;
 243     }
 244
 245     private CompositeNode prepareCnStructForYangData(final Object data, final String leafName) {
 246         MutableCompositeNode cont = NodeFactory.createMutableCompositeNode(TestUtils.buildQName("cont"), null, null,
 247                 ModifyAction.CREATE, null);
 248
 249         MutableSimpleNode<Object> lf1 = NodeFactory.createMutableSimpleNode(TestUtils.buildQName(leafName), cont, data,
 250                 ModifyAction.CREATE, null);
 251         cont.getValue().add(lf1);
 252         cont.init();
 253
 254         return cont;
 255     }
 256
 257     private CompositeNode prepareLeafrefData() {
 258         MutableCompositeNode cont = NodeFactory.createMutableCompositeNode(TestUtils.buildQName("cont"), null, null,
 259                 ModifyAction.CREATE, null);
 260
 261         MutableSimpleNode<Object> lfBoolean = NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfBoolean"),
 262                 cont, Boolean.TRUE, ModifyAction.CREATE, null);
 263         MutableSimpleNode<Object> lfLfref = NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfLfref"), cont,
 264                 "true", ModifyAction.CREATE, null);
 265         cont.getValue().add(lfBoolean);
 266         cont.getValue().add(lfLfref);
 267         cont.init();
 268
 269         return cont;
 270     }
 271
 272 }