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