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.*;
   4
   5 import java.io.StringWriter;
   6 import java.util.Set;
   7
   8 import javax.activation.UnsupportedDataTypeException;
   9 import javax.xml.transform.*;
  10 import javax.xml.transform.dom.DOMSource;
  11 import javax.xml.transform.stream.StreamResult;
  12
  13 import org.junit.BeforeClass;
  14 import org.junit.Test;
  15 import org.opendaylight.controller.sal.rest.impl.XmlMapper;
  16 import org.opendaylight.controller.sal.restconf.impl.test.TestUtils;
  17 import org.opendaylight.yangtools.yang.data.api.*;
  18 import org.opendaylight.yangtools.yang.data.impl.NodeFactory;
  19 import org.opendaylight.yangtools.yang.data.impl.codec.TypeDefinitionAwareCodec;
  20 import org.opendaylight.yangtools.yang.model.api.*;
  21 import org.w3c.dom.Document;
  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 {
  31
  32     private static Set<Module> modules;
  33     private static DataSchemaNode dataSchemaNode;
  34
  35     @BeforeClass
  36     public static void initialization() {
  37         modules = TestUtils.resolveModules("/cnsn-to-xml/yang");
  38         assertEquals(2, modules.size());
  39         Module module = TestUtils.resolveModule("basic-module", modules);
  40         assertNotNull(module);
  41         dataSchemaNode = TestUtils.resolveDataSchemaNode(module, "cont");
  42         assertNotNull(dataSchemaNode);
  43
  44     }
  45
  46     @Test
  47     public void snAsYangIdentityrefToXMLTest() {
  48         serializeToXml(prepareIdentityrefData(), "<lf11 xmlns:x=\"referenced:module\">x:iden</lf11>");
  49     }
  50
  51     @Test
  52     public void snAsYangStringToXmlTest() {
  53         serializeToXml(
  54                 prepareCnStructForYangData(TypeDefinitionAwareCodec.STRING_DEFAULT_CODEC.deserialize("lfStr value"),
  55                         "lfStr"), "<lfStr>lfStr value</lfStr>");
  56     }
  57
  58     @Test
  59     public void snAsYangInt8ToXmlTest() {
  60         String elName = "lfInt8";
  61         serializeToXml(
  62                 prepareCnStructForYangData(TypeDefinitionAwareCodec.INT8_DEFAULT_CODEC.deserialize("14"), elName), "<"
  63                         + elName + ">14</" + elName + ">");
  64     }
  65
  66     @Test
  67     public void snAsYangInt16ToXmlTest() {
  68         String elName = "lfInt16";
  69         serializeToXml(
  70                 prepareCnStructForYangData(TypeDefinitionAwareCodec.INT16_DEFAULT_CODEC.deserialize("3000"), elName),
  71                 "<" + elName + ">3000</" + elName + ">");
  72     }
  73
  74     @Test
  75     public void snAsYangInt32ToXmlTest() {
  76         String elName = "lfInt32";
  77         serializeToXml(
  78                 prepareCnStructForYangData(TypeDefinitionAwareCodec.INT32_DEFAULT_CODEC.deserialize("201234"), elName),
  79                 "<" + elName + ">201234</" + elName + ">");
  80     }
  81
  82     @Test
  83     public void snAsYangInt64ToXmlTest() {
  84         String elName = "lfInt64";
  85         serializeToXml(
  86                 prepareCnStructForYangData(TypeDefinitionAwareCodec.INT64_DEFAULT_CODEC.deserialize("5123456789"),
  87                         elName), "<" + elName + ">5123456789</" + elName + ">");
  88     }
  89
  90     @Test
  91     public void snAsYangUint8ToXmlTest() {
  92         String elName = "lfUint8";
  93         serializeToXml(
  94                 prepareCnStructForYangData(TypeDefinitionAwareCodec.UINT8_DEFAULT_CODEC.deserialize("200"), elName),
  95                 "<" + elName + ">200</" + elName + ">");
  96     }
  97
  98     @Test
  99     public void snAsYangUint16ToXmlTest() {
 100         String elName = "lfUint16";
 101         serializeToXml(
 102                 prepareCnStructForYangData(TypeDefinitionAwareCodec.UINT16_DEFAULT_CODEC.deserialize("4000"), elName),
 103                 "<" + elName + ">4000</" + elName + ">");
 104     }
 105
 106     @Test
 107     public void snAsYangUint32ToXmlTest() {
 108         String elName = "lfUint32";
 109         serializeToXml(
 110                 prepareCnStructForYangData(TypeDefinitionAwareCodec.UINT32_DEFAULT_CODEC.deserialize("4123456789"),
 111                         elName), "<" + elName + ">4123456789</" + elName + ">");
 112     }
 113
 114     @Test
 115     public void snAsYangUint64ToXmlTest() {
 116         String elName = "lfUint64";
 117         serializeToXml(
 118                 prepareCnStructForYangData(TypeDefinitionAwareCodec.UINT64_DEFAULT_CODEC.deserialize("5123456789"),
 119                         elName), "<" + elName + ">5123456789</" + elName + ">");
 120     }
 121
 122     @Test
 123     public void snAsYangBinaryToXmlTest() {
 124         String elName = "lfBinary";
 125         serializeToXml(
 126                 prepareCnStructForYangData(
 127                         TypeDefinitionAwareCodec.BINARY_DEFAULT_CODEC
 128                                 .deserialize("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567"),
 129                         elName), "<" + elName + ">ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567</"
 130                         + elName + ">");
 131     }
 132
 133     @Test
 134     public void snAsYangBitsToXmlTest() {
 135         String elName = "lfBits";
 136         serializeToXml(
 137                 prepareCnStructForYangData(TypeDefinitionAwareCodec.BITS_DEFAULT_CODEC.deserialize("one two"), elName),
 138                 "<" + elName + ">one two</" + elName + ">", "<" + elName + ">two one</" + elName + ">");
 139     }
 140
 141     @Test
 142     public void snAsYangEnumerationToXmlTest() {
 143         String elName = "lfEnumeration";
 144         serializeToXml(
 145                 prepareCnStructForYangData(TypeDefinitionAwareCodec.ENUMERATION_DEFAULT_CODEC.deserialize("enum2"),
 146                         elName), "<" + elName + ">enum2</" + elName + ">");
 147     }
 148
 149     @Test
 150     public void snAsYangEmptyToXmlTest() {
 151         String elName = "lfEmpty";
 152         serializeToXml(
 153                 prepareCnStructForYangData(TypeDefinitionAwareCodec.EMPTY_DEFAULT_CODEC.deserialize(null), elName), "<"
 154                         + elName + "/>");
 155     }
 156
 157     @Test
 158     public void snAsYangBooleanToXmlTest() {
 159         String elName = "lfBoolean";
 160         serializeToXml(
 161                 prepareCnStructForYangData(TypeDefinitionAwareCodec.BOOLEAN_DEFAULT_CODEC.deserialize("str"), elName),
 162                 "<" + elName + ">false</" + elName + ">");
 163         serializeToXml(
 164                 prepareCnStructForYangData(TypeDefinitionAwareCodec.BOOLEAN_DEFAULT_CODEC.deserialize("true"), elName),
 165                 "<" + elName + ">true</" + elName + ">");
 166     }
 167
 168     @Test
 169     public void snAsYangUnionToXmlTest() {
 170         String elName = "lfUnion";
 171         String int8 = "15";
 172         serializeToXml(
 173                 prepareCnStructForYangData(TypeDefinitionAwareCodec.UNION_DEFAULT_CODEC.deserialize(int8), elName), "<"
 174                         + elName + ">15</" + elName + ">");
 175
 176         String bits = "first second";
 177         serializeToXml(
 178                 prepareCnStructForYangData(TypeDefinitionAwareCodec.UNION_DEFAULT_CODEC.deserialize(bits), elName), "<"
 179                         + elName + ">first second</" + elName + ">");
 180
 181         String bool = "str";
 182         serializeToXml(
 183                 prepareCnStructForYangData(TypeDefinitionAwareCodec.UNION_DEFAULT_CODEC.deserialize(bool), elName), "<"
 184                         + elName + ">str</" + elName + ">");
 185     }
 186
 187     private void serializeToXml(CompositeNode compositeNode, String... xmlRepresentation)
 188             throws TransformerFactoryConfigurationError {
 189         XmlMapper xmlMapper = new XmlMapper();
 190         String xmlString = null;
 191         if (dataSchemaNode instanceof DataNodeContainer) {
 192             try {
 193                 Document doc = xmlMapper.write(compositeNode, (DataNodeContainer) dataSchemaNode);
 194                 DOMSource domSource = new DOMSource(doc);
 195                 StringWriter writer = new StringWriter();
 196                 StreamResult result = new StreamResult(writer);
 197                 TransformerFactory tf = TransformerFactory.newInstance();
 198                 Transformer transformer = tf.newTransformer();
 199                 transformer.transform(domSource, result);
 200                 xmlString = writer.toString();
 201             } catch (UnsupportedDataTypeException | TransformerException e) {
 202             }
 203         }
 204         assertNotNull(xmlMapper);
 205         boolean containSearchedStr = false;
 206         String strRepresentation = "";
 207         for (String searchedStr : xmlRepresentation) {
 208             if (xmlString.contains(searchedStr)) {
 209                 containSearchedStr = true;
 210                 break;
 211             }
 212             strRepresentation = strRepresentation + "[" + searchedStr + "]";
 213         }
 214         assertTrue("At least one of specified strings " + strRepresentation + " wasn't found.", containSearchedStr);
 215
 216     }
 217
 218     private CompositeNode prepareIdentityrefData() {
 219         MutableCompositeNode cont = NodeFactory.createMutableCompositeNode(
 220                 TestUtils.buildQName("cont", "basic:module", "2013-12-2"), null, null, ModifyAction.CREATE, null);
 221         MutableCompositeNode cont1 = NodeFactory.createMutableCompositeNode(
 222                 TestUtils.buildQName("cont1", "basic:module", "2013-12-2"), cont, null, ModifyAction.CREATE, null);
 223         cont.getChildren().add(cont1);
 224
 225         MutableSimpleNode<Object> lf11 = NodeFactory.createMutableSimpleNode(
 226                 TestUtils.buildQName("lf11", "basic:module", "2013-12-2"), cont1,
 227                 TestUtils.buildQName("iden", "referenced:module", "2013-12-2"), 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 }