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