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

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