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 import java.util.List;
  15
  16 import javax.ws.rs.WebApplicationException;
  17 import javax.xml.transform.TransformerFactoryConfigurationError;
  18
  19 import org.junit.BeforeClass;
  20 import org.junit.Test;
  21
  22 import static org.mockito.Mockito.*;
  23
  24 import org.opendaylight.controller.sal.rest.impl.StructuredDataToXmlProvider;
  25 import org.opendaylight.controller.sal.restconf.impl.test.TestUtils;
  26 import org.opendaylight.controller.sal.restconf.impl.test.YangAndXmlAndDataSchemaLoader;
  27 import org.opendaylight.yangtools.yang.data.api.CompositeNode;
  28 import org.opendaylight.yangtools.yang.data.api.ModifyAction;
  29 import org.opendaylight.yangtools.yang.data.api.MutableCompositeNode;
  30 import org.opendaylight.yangtools.yang.data.api.MutableSimpleNode;
  31 import org.opendaylight.yangtools.yang.data.impl.NodeFactory;
  32 import org.opendaylight.yangtools.yang.data.impl.codec.TypeDefinitionAwareCodec;
  33 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  34 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
  35 import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
  36 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
  37 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
  38 import org.opendaylight.yangtools.yang.model.util.BinaryType;
  39 import org.opendaylight.yangtools.yang.model.util.BitsType;
  40 import org.opendaylight.yangtools.yang.model.util.BooleanType;
  41 import org.opendaylight.yangtools.yang.model.util.EmptyType;
  42 import org.opendaylight.yangtools.yang.model.util.EnumerationType;
  43 import org.opendaylight.yangtools.yang.model.util.Int16;
  44 import org.opendaylight.yangtools.yang.model.util.Int32;
  45 import org.opendaylight.yangtools.yang.model.util.Int64;
  46 import org.opendaylight.yangtools.yang.model.util.Int8;
  47 import org.opendaylight.yangtools.yang.model.util.StringType;
  48 import org.opendaylight.yangtools.yang.model.util.Uint16;
  49 import org.opendaylight.yangtools.yang.model.util.Uint32;
  50 import org.opendaylight.yangtools.yang.model.util.Uint64;
  51 import org.opendaylight.yangtools.yang.model.util.Uint8;
  52 import org.opendaylight.yangtools.yang.model.util.UnionType;
  53
  54 import com.google.common.base.Optional;
  55 import com.google.common.collect.Lists;
  56
  57 /**
  58  *
  59  * CnSn = Composite node and Simple node data structure Class contains test of
  60  * serializing simple nodes data values according data types from YANG schema to
  61  * XML file
  62  *
  63  */
  64 public class CnSnToXmlTest extends YangAndXmlAndDataSchemaLoader {
  65     @BeforeClass
  66     public static void initialization() {
  67         dataLoad("/cnsn-to-xml/yang", 2, "basic-module", "cont");
  68     }
  69
  70     @Test
  71     public void snAsYangIdentityrefToXMLTest() {
  72         serializeToXml(prepareIdentityrefData(null, true), "<lf11 xmlns:x=\"referenced:module\">x:iden</lf11>");
  73     }
  74
  75     @Test
  76     public void snAsYangIdentityrefWithQNamePrefixToXMLTest() {
  77         serializeToXml(prepareIdentityrefData("prefix", true),
  78                 "<lf11 xmlns:prefix=\"referenced:module\">prefix:iden</lf11>");
  79     }
  80
  81     @Test
  82     public void snAsYangIdentityrefWithPrefixToXMLTest() {
  83         serializeToXml(prepareIdentityrefData("prefix", false), "<lf11>no qname value</lf11>");
  84     }
  85
  86     @Test
  87     public void snAsYangLeafrefWithPrefixToXMLTest() {
  88         serializeToXml(prepareLeafrefData(), "<lfBoolean>true</lfBoolean>", "<lfLfref>true</lfLfref>");
  89     }
  90
  91
  92     @Test
  93     public void snAsYangStringToXmlTest() {
  94         serializeToXml(
  95                 prepareCnStructForYangData(TypeDefinitionAwareCodec.from(StringType.getInstance()).deserialize("lfStr value"),
  96                         "lfStr"), "<lfStr>lfStr value</lfStr>");
  97     }
  98
  99     @Test
 100     public void snAsYangInt8ToXmlTest() {
 101         String elName = "lfInt8";
 102         serializeToXml(
 103                 prepareCnStructForYangData(TypeDefinitionAwareCodec.from(Int8.getInstance()).deserialize("14"), elName), "<"
 104                         + elName + ">14</" + elName + ">");
 105     }
 106
 107     @Test
 108     public void snAsYangInt16ToXmlTest() {
 109         String elName = "lfInt16";
 110         serializeToXml(
 111                 prepareCnStructForYangData(TypeDefinitionAwareCodec.from(Int16.getInstance()).deserialize("3000"), elName),
 112                 "<" + elName + ">3000</" + elName + ">");
 113     }
 114
 115     @Test
 116     public void snAsYangInt32ToXmlTest() {
 117         String elName = "lfInt32";
 118         serializeToXml(
 119                 prepareCnStructForYangData(TypeDefinitionAwareCodec.from(Int32.getInstance()).deserialize("201234"), elName),
 120                 "<" + elName + ">201234</" + elName + ">");
 121     }
 122
 123     @Test
 124     public void snAsYangInt64ToXmlTest() {
 125         String elName = "lfInt64";
 126         serializeToXml(
 127                 prepareCnStructForYangData(TypeDefinitionAwareCodec.from(Int64.getInstance()).deserialize("5123456789"),
 128                         elName), "<" + elName + ">5123456789</" + elName + ">");
 129     }
 130
 131     @Test
 132     public void snAsYangUint8ToXmlTest() {
 133         String elName = "lfUint8";
 134         serializeToXml(
 135                 prepareCnStructForYangData(TypeDefinitionAwareCodec.from(Uint8.getInstance()).deserialize("200"), elName),
 136                 "<" + elName + ">200</" + elName + ">");
 137     }
 138
 139     @Test
 140     public void snAsYangUint16ToXmlTest() {
 141         String elName = "lfUint16";
 142         serializeToXml(
 143                 prepareCnStructForYangData(TypeDefinitionAwareCodec.from(Uint16.getInstance()).deserialize("4000"), elName),
 144                 "<" + elName + ">4000</" + elName + ">");
 145     }
 146
 147     @Test
 148     public void snAsYangUint32ToXmlTest() {
 149         String elName = "lfUint32";
 150         serializeToXml(
 151                 prepareCnStructForYangData(TypeDefinitionAwareCodec.from(Uint32.getInstance()).deserialize("4123456789"),
 152                         elName), "<" + elName + ">4123456789</" + elName + ">");
 153     }
 154
 155     @Test
 156     public void snAsYangUint64ToXmlTest() {
 157         String elName = "lfUint64";
 158         serializeToXml(
 159                 prepareCnStructForYangData(TypeDefinitionAwareCodec.from(Uint64.getInstance()).deserialize("5123456789"),
 160                         elName), "<" + elName + ">5123456789</" + elName + ">");
 161     }
 162
 163     @Test
 164     public void snAsYangBinaryToXmlTest() {
 165         String elName = "lfBinary";
 166         serializeToXml(
 167                 prepareCnStructForYangData(
 168                         TypeDefinitionAwareCodec.from(BinaryType.getInstance())
 169                                 .deserialize("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567"),
 170                         elName), "<" + elName + ">ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567</"
 171                         + elName + ">");
 172     }
 173
 174     @Test
 175     public void snAsYangBitsToXmlTest() {
 176         BitsTypeDefinition.Bit mockBit1 = mock( BitsTypeDefinition.Bit.class );
 177         when( mockBit1.getName() ).thenReturn( "one" );
 178         BitsTypeDefinition.Bit mockBit2 = mock( BitsTypeDefinition.Bit.class );
 179         when( mockBit2.getName() ).thenReturn( "two" );
 180         List<BitsTypeDefinition.Bit> bitList = Lists.newArrayList( mockBit1, mockBit2 );
 181
 182         String elName = "lfBits";
 183         serializeToXml(
 184                 prepareCnStructForYangData(TypeDefinitionAwareCodec.from(
 185                                 BitsType.create( mock( SchemaPath.class ), bitList ) )
 186                                                                .deserialize("one two"), elName),
 187                 "<" + elName + ">one two</" + elName + ">", "<" + elName + ">two one</" + elName + ">");
 188     }
 189
 190     @Test
 191     public void snAsYangEnumerationToXmlTest() {
 192         EnumTypeDefinition.EnumPair mockEnum = mock( EnumTypeDefinition.EnumPair.class );
 193         when( mockEnum.getName() ).thenReturn( "enum2" );
 194         List<EnumPair> enumList = Lists.newArrayList( mockEnum );
 195
 196         String elName = "lfEnumeration";
 197         serializeToXml(
 198                 prepareCnStructForYangData(TypeDefinitionAwareCodec.from(
 199                     EnumerationType.create( mock( SchemaPath.class ), enumList,
 200                                             Optional.<EnumTypeDefinition.EnumPair>absent() ) )
 201                                                                                     .deserialize("enum2"),
 202                         elName), "<" + elName + ">enum2</" + elName + ">");
 203     }
 204
 205     @Test
 206     public void snAsYangEmptyToXmlTest() {
 207         String elName = "lfEmpty";
 208         serializeToXml(
 209                 prepareCnStructForYangData(TypeDefinitionAwareCodec.from(EmptyType.getInstance()).deserialize(null), elName), "<"
 210                         + elName + "/>");
 211     }
 212
 213     @Test
 214     public void snAsYangBooleanToXmlTest() {
 215         String elName = "lfBoolean";
 216         serializeToXml(
 217                 prepareCnStructForYangData(TypeDefinitionAwareCodec.from(BooleanType.getInstance()).deserialize("str"), elName),
 218                 "<" + elName + ">false</" + elName + ">");
 219         serializeToXml(
 220                 prepareCnStructForYangData(TypeDefinitionAwareCodec.from(BooleanType.getInstance()).deserialize("true"), elName),
 221                 "<" + elName + ">true</" + elName + ">");
 222     }
 223
 224     @Test
 225     public void snAsYangUnionToXmlTest() {
 226
 227         BitsTypeDefinition.Bit mockBit1 = mock( BitsTypeDefinition.Bit.class );
 228         when( mockBit1.getName() ).thenReturn( "first" );
 229         BitsTypeDefinition.Bit mockBit2 = mock( BitsTypeDefinition.Bit.class );
 230         when( mockBit1.getName() ).thenReturn( "second" );
 231         List<BitsTypeDefinition.Bit> bitList = Lists.newArrayList( mockBit1, mockBit2 );
 232
 233         List<TypeDefinition<?>> types = Lists.<TypeDefinition<?>>newArrayList(
 234                                                             Int8.getInstance(),
 235                                                             BitsType.create( mock( SchemaPath.class ) , bitList ),
 236                                                             BooleanType.getInstance() );
 237         UnionType unionType = UnionType.create( types );
 238
 239         String elName = "lfUnion";
 240         String int8 = "15";
 241         serializeToXml(
 242                 prepareCnStructForYangData(TypeDefinitionAwareCodec.from(unionType).deserialize(int8), elName), "<"
 243                         + elName + ">15</" + elName + ">");
 244
 245         String bits = "first second";
 246         serializeToXml(
 247                 prepareCnStructForYangData(TypeDefinitionAwareCodec.from(unionType).deserialize(bits), elName), "<"
 248                         + elName + ">first second</" + elName + ">");
 249
 250         String bool = "str";
 251         serializeToXml(
 252                 prepareCnStructForYangData(TypeDefinitionAwareCodec.from(unionType).deserialize(bool), elName), "<"
 253                         + elName + ">str</" + elName + ">");
 254     }
 255
 256     private void serializeToXml(CompositeNode compositeNode, String... xmlRepresentation)
 257             throws TransformerFactoryConfigurationError {
 258         String xmlString = "";
 259         try {
 260             xmlString = TestUtils.writeCompNodeWithSchemaContextToOutput(compositeNode, modules, dataSchemaNode,
 261                     StructuredDataToXmlProvider.INSTANCE);
 262         } catch (WebApplicationException | IOException e) {
 263         }
 264         assertNotNull(xmlString);
 265         boolean containSearchedStr = false;
 266         String strRepresentation = "";
 267         for (String searchedStr : xmlRepresentation) {
 268             if (xmlString.contains(searchedStr)) {
 269                 containSearchedStr = true;
 270                 break;
 271             }
 272             strRepresentation = strRepresentation + "[" + searchedStr + "]";
 273         }
 274         assertTrue("At least one of specified strings " + strRepresentation + " wasn't found.", containSearchedStr);
 275
 276     }
 277
 278     private CompositeNode prepareIdentityrefData(String prefix, boolean valueAsQName) {
 279         MutableCompositeNode cont = NodeFactory.createMutableCompositeNode(
 280                 TestUtils.buildQName("cont", "basic:module", "2013-12-2"), null, null, ModifyAction.CREATE, null);
 281         MutableCompositeNode cont1 = NodeFactory.createMutableCompositeNode(
 282                 TestUtils.buildQName("cont1", "basic:module", "2013-12-2"), cont, null, ModifyAction.CREATE, null);
 283         cont.getValue().add(cont1);
 284
 285         Object value = null;
 286         if (valueAsQName) {
 287             value = TestUtils.buildQName("iden", "referenced:module", "2013-12-2", prefix);
 288         } else {
 289             value = "no qname value";
 290         }
 291         MutableSimpleNode<Object> lf11 = NodeFactory.createMutableSimpleNode(
 292                 TestUtils.buildQName("lf11", "basic:module", "2013-12-2"), cont1, value, ModifyAction.CREATE, null);
 293         cont1.getValue().add(lf11);
 294         cont1.init();
 295         cont.init();
 296
 297         return cont;
 298     }
 299
 300     private CompositeNode prepareCnStructForYangData(final Object data, final String leafName) {
 301         MutableCompositeNode cont = NodeFactory.createMutableCompositeNode(TestUtils.buildQName("cont"), null, null,
 302                 ModifyAction.CREATE, null);
 303
 304         MutableSimpleNode<Object> lf1 = NodeFactory.createMutableSimpleNode(TestUtils.buildQName(leafName), cont, data,
 305                 ModifyAction.CREATE, null);
 306         cont.getValue().add(lf1);
 307         cont.init();
 308
 309         return cont;
 310     }
 311
 312     private CompositeNode prepareLeafrefData() {
 313         MutableCompositeNode cont = NodeFactory.createMutableCompositeNode(TestUtils.buildQName("cont"), null, null,
 314                 ModifyAction.CREATE, null);
 315
 316         MutableSimpleNode<Object> lfBoolean = NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfBoolean"),
 317                 cont, Boolean.TRUE, ModifyAction.CREATE, null);
 318         MutableSimpleNode<Object> lfLfref = NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfLfref"), cont,
 319                 "true", ModifyAction.CREATE, null);
 320         cont.getValue().add(lfBoolean);
 321         cont.getValue().add(lfLfref);
 322         cont.init();
 323
 324         return cont;
 325     }
 326
 327 }