opendaylight/md-sal/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/nn/to/xml/test/NnToXmlTest.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.nn.to.xml.test;
   9
  10 import static org.junit.Assert.assertTrue;
  11
  12 import com.google.common.base.Optional;
  13 import com.google.common.collect.Iterables;
  14 import com.google.common.collect.Lists;
  15 import java.io.ByteArrayOutputStream;
  16 import java.io.OutputStream;
  17 import java.util.List;
  18 import javax.ws.rs.core.MediaType;
  19 import org.junit.BeforeClass;
  20 import org.junit.Test;
  21 import org.mockito.Mockito;
  22 import org.opendaylight.controller.sal.rest.impl.NormalizedNodeXmlBodyWriter;
  23 import org.opendaylight.controller.sal.rest.impl.test.providers.AbstractBodyReaderTest;
  24 import org.opendaylight.controller.sal.restconf.impl.ControllerContext;
  25 import org.opendaylight.controller.sal.restconf.impl.InstanceIdentifierContext;
  26 import org.opendaylight.controller.sal.restconf.impl.NormalizedNodeContext;
  27 import org.opendaylight.yangtools.yang.common.QName;
  28 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  29 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  30 import org.opendaylight.yangtools.yang.data.impl.codec.TypeDefinitionAwareCodec;
  31 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
  32 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
  33 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
  34 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
  35 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  36 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
  37 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  38 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  39 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
  40 import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
  41 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
  42 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
  43 import org.opendaylight.yangtools.yang.model.util.BinaryType;
  44 import org.opendaylight.yangtools.yang.model.util.BitsType;
  45 import org.opendaylight.yangtools.yang.model.util.BooleanType;
  46 import org.opendaylight.yangtools.yang.model.util.EmptyType;
  47 import org.opendaylight.yangtools.yang.model.util.EnumerationType;
  48 import org.opendaylight.yangtools.yang.model.util.Int16;
  49 import org.opendaylight.yangtools.yang.model.util.Int32;
  50 import org.opendaylight.yangtools.yang.model.util.Int64;
  51 import org.opendaylight.yangtools.yang.model.util.Int8;
  52 import org.opendaylight.yangtools.yang.model.util.StringType;
  53 import org.opendaylight.yangtools.yang.model.util.Uint16;
  54 import org.opendaylight.yangtools.yang.model.util.Uint32;
  55 import org.opendaylight.yangtools.yang.model.util.Uint64;
  56 import org.opendaylight.yangtools.yang.model.util.Uint8;
  57 import org.opendaylight.yangtools.yang.model.util.UnionType;
  58
  59 public class NnToXmlTest extends AbstractBodyReaderTest {
  60
  61     private final NormalizedNodeXmlBodyWriter xmlBodyWriter;
  62     private static SchemaContext schemaContext;
  63
  64     public NnToXmlTest() throws NoSuchFieldException, SecurityException {
  65         super();
  66         xmlBodyWriter = new NormalizedNodeXmlBodyWriter();
  67     }
  68
  69     @BeforeClass
  70     public static void initialization() {
  71         schemaContext = schemaContextLoader("/nn-to-xml/yang", schemaContext);
  72         controllerContext.setSchemas(schemaContext);
  73     }
  74
  75     @Test
  76     public void nnAsYangIdentityrefToXMLTest() throws Exception {
  77         final NormalizedNodeContext normalizedNodeContext = prepareIdrefData(null,
  78                 true);
  79         nnToXml(normalizedNodeContext,
  80                 "<lf11 xmlns:x=\"referenced:module\">x:iden</lf11>");
  81     }
  82
  83     @Test
  84     public void nnAsYangIdentityrefWithQNamePrefixToXMLTest() throws Exception {
  85         final NormalizedNodeContext normalizedNodeContext = prepareIdrefData(
  86                 "prefix", true);
  87         nnToXml(normalizedNodeContext, "<lf11 xmlns",
  88                 "=\"referenced:module\">", ":iden</lf11>");
  89     }
  90
  91     @Test
  92     public void nnAsYangIdentityrefWithPrefixToXMLTest() throws Exception {
  93         final NormalizedNodeContext normalizedNodeContext = prepareIdrefData(
  94                 "prefix", false);
  95         nnToXml(normalizedNodeContext, "<lf11>no qname value</lf11>");
  96     }
  97
  98     @Test
  99     public void nnAsYangLeafrefWithPrefixToXMLTest() throws Exception {
 100         final NormalizedNodeContext normalizedNodeContext = prepareLeafrefData();
 101         nnToXml(normalizedNodeContext, "<lfBoolean>true</lfBoolean>",
 102                 "<lfLfref>true</lfLfref>");
 103     }
 104
 105     @Test
 106     public void nnAsYangStringToXmlTest() throws Exception {
 107         final NormalizedNodeContext normalizedNodeContext = prepareNNC(
 108                 TypeDefinitionAwareCodec.from(StringType.getInstance())
 109                         .deserialize("lfStr value"), "lfStr");
 110         nnToXml(normalizedNodeContext, "<lfStr>lfStr value</lfStr>");
 111     }
 112
 113     @Test
 114     public void nnAsYangInt8ToXmlTest() throws Exception {
 115         final String elName = "lfInt8";
 116
 117         final NormalizedNodeContext normalizedNodeContext = prepareNNC(
 118                 TypeDefinitionAwareCodec.from(Int8.getInstance()).deserialize(
 119                         "14"), elName);
 120         nnToXml(normalizedNodeContext, "<" + elName + ">14</" + elName
 121                 + ">");
 122     }
 123
 124     @Test
 125     public void nnAsYangInt16ToXmlTest() throws Exception {
 126         final String elName = "lfInt16";
 127
 128         final NormalizedNodeContext normalizedNodeContext = prepareNNC(
 129                 TypeDefinitionAwareCodec.from(Int16.getInstance()).deserialize(
 130                         "3000"), elName);
 131         nnToXml(normalizedNodeContext, "<" + elName + ">3000</" + elName
 132                 + ">");
 133     }
 134
 135     @Test
 136     public void nnAsYangInt32ToXmlTest() throws Exception {
 137         final String elName = "lfInt32";
 138
 139         final NormalizedNodeContext normalizedNodeContext = prepareNNC(
 140                 TypeDefinitionAwareCodec.from(Int32.getInstance()).deserialize(
 141                         "201234"), elName);
 142         nnToXml(normalizedNodeContext, "<" + elName + ">201234</"
 143                 + elName + ">");
 144     }
 145
 146     @Test
 147     public void nnAsYangInt64ToXmlTest() throws Exception {
 148         final String elName = "lfInt64";
 149
 150         final NormalizedNodeContext normalizedNodeContext = prepareNNC(
 151                 TypeDefinitionAwareCodec.from(Int64.getInstance()).deserialize(
 152                         "5123456789"), elName);
 153         nnToXml(normalizedNodeContext, "<" + elName + ">5123456789</"
 154                 + elName + ">");
 155     }
 156
 157     @Test
 158     public void nnAsYangUint8ToXmlTest() throws Exception {
 159         final String elName = "lfUint8";
 160
 161         final NormalizedNodeContext normalizedNodeContext = prepareNNC(
 162                 TypeDefinitionAwareCodec.from(Uint8.getInstance()).deserialize(
 163                         "200"), elName);
 164         nnToXml(normalizedNodeContext, "<" + elName + ">200</" + elName
 165                 + ">");
 166     }
 167
 168     @Test
 169     public void snAsYangUint16ToXmlTest() throws Exception {
 170         final String elName = "lfUint16";
 171
 172         final NormalizedNodeContext normalizedNodeContext = prepareNNC(
 173                 TypeDefinitionAwareCodec.from(Uint16.getInstance())
 174                         .deserialize("4000"), elName);
 175         nnToXml(normalizedNodeContext, "<" + elName + ">4000</" + elName
 176                 + ">");
 177     }
 178
 179     @Test
 180     public void nnAsYangUint32ToXmlTest() throws Exception {
 181         final String elName = "lfUint32";
 182
 183         final NormalizedNodeContext normalizedNodeContext = prepareNNC(
 184                 TypeDefinitionAwareCodec.from(Uint32.getInstance())
 185                         .deserialize("4123456789"), elName);
 186         nnToXml(normalizedNodeContext, "<" + elName + ">4123456789</"
 187                 + elName + ">");
 188     }
 189
 190     @Test
 191     public void snAsYangUint64ToXmlTest() throws Exception {
 192         final String elName = "lfUint64";
 193         final NormalizedNodeContext normalizedNodeContext = prepareNNC(
 194                 TypeDefinitionAwareCodec.from(Uint64.getInstance())
 195                         .deserialize("5123456789"), elName);
 196         nnToXml(normalizedNodeContext, "<" + elName + ">5123456789</"
 197                 + elName + ">");
 198     }
 199
 200     @Test
 201     public void nnAsYangBinaryToXmlTest() throws Exception {
 202         final String elName = "lfBinary";
 203         final NormalizedNodeContext normalizedNodeContext = prepareNNC(
 204                 TypeDefinitionAwareCodec
 205                         .from(BinaryType.getInstance())
 206                         .deserialize(
 207                                 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567"),
 208                 elName);
 209         nnToXml(
 210                 normalizedNodeContext,
 211                 "<"
 212                         + elName
 213                         + ">ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567</"
 214                         + elName + ">");
 215     }
 216
 217     @Test
 218     public void nnAsYangBitsToXmlTest() throws Exception {
 219         final BitsTypeDefinition.Bit mockBit1 = Mockito
 220                 .mock(BitsTypeDefinition.Bit.class);
 221         Mockito.when(mockBit1.getName()).thenReturn("one");
 222         final BitsTypeDefinition.Bit mockBit2 = Mockito
 223                 .mock(BitsTypeDefinition.Bit.class);
 224         Mockito.when(mockBit2.getName()).thenReturn("two");
 225         final List<BitsTypeDefinition.Bit> bitList = Lists.newArrayList(
 226                 mockBit1, mockBit2);
 227
 228         final String elName = "lfBits";
 229         final NormalizedNodeContext normalizedNodeContext = prepareNNC(
 230                 TypeDefinitionAwareCodec
 231                         .from(BitsType.create(Mockito.mock(SchemaPath.class),
 232                                 bitList)).deserialize("one two"), elName);
 233         nnToXml(normalizedNodeContext, "<" + elName + ">one two</"
 234                 + elName + ">");
 235     }
 236
 237     @Test
 238     public void nnAsYangEnumerationToXmlTest() throws Exception {
 239         final EnumTypeDefinition.EnumPair mockEnum = Mockito
 240                 .mock(EnumTypeDefinition.EnumPair.class);
 241         Mockito.when(mockEnum.getName()).thenReturn("enum2");
 242         final List<EnumPair> enumList = Lists.newArrayList(mockEnum);
 243
 244         final String elName = "lfEnumeration";
 245         final NormalizedNodeContext normalizedNodeContext = prepareNNC(
 246                 TypeDefinitionAwareCodec
 247                         .from(EnumerationType.create(
 248                                 Mockito.mock(SchemaPath.class), enumList,
 249                                 Optional.<EnumTypeDefinition.EnumPair> absent()))
 250                         .deserialize("enum2"), elName);
 251         nnToXml(normalizedNodeContext, "<" + elName + ">enum2</"
 252                 + elName + ">");
 253     }
 254
 255     @Test
 256     public void nnAsYangEmptyToXmlTest() throws Exception {
 257         final String elName = "lfEmpty";
 258         final NormalizedNodeContext normalizedNodeContext = prepareNNC(
 259                 TypeDefinitionAwareCodec.from(EmptyType.getInstance())
 260                         .deserialize(null), elName);
 261         nnToXml(normalizedNodeContext, "<" + elName + "></" + elName
 262                 + ">");
 263     }
 264
 265     @Test
 266     public void nnAsYangBooleanToXmlTest() throws Exception {
 267         final String elName = "lfBoolean";
 268         NormalizedNodeContext normalizedNodeContext = prepareNNC(
 269                 TypeDefinitionAwareCodec.from(BooleanType.getInstance())
 270 .deserialize("false"), elName);
 271         nnToXml(normalizedNodeContext, "<" + elName + ">false</"
 272                 + elName + ">");
 273
 274         normalizedNodeContext = prepareNNC(
 275                 TypeDefinitionAwareCodec.from(BooleanType.getInstance())
 276                         .deserialize("true"), elName);
 277         nnToXml(normalizedNodeContext, "<" + elName + ">true</" + elName
 278                 + ">");
 279     }
 280
 281     @Test
 282     public void nnAsYangUnionToXmlTest() throws Exception {
 283
 284         final BitsTypeDefinition.Bit mockBit1 = Mockito
 285                 .mock(BitsTypeDefinition.Bit.class);
 286         Mockito.when(mockBit1.getName()).thenReturn("first");
 287         final BitsTypeDefinition.Bit mockBit2 = Mockito
 288                 .mock(BitsTypeDefinition.Bit.class);
 289         Mockito.when(mockBit2.getName()).thenReturn("second");
 290         final List<BitsTypeDefinition.Bit> bitList = Lists.newArrayList(
 291                 mockBit1, mockBit2);
 292
 293         final List<TypeDefinition<?>> types = Lists
 294                 .<TypeDefinition<?>> newArrayList(Int8.getInstance(), BitsType
 295                         .create(Mockito.mock(SchemaPath.class), bitList),
 296                         BooleanType.getInstance());
 297         final UnionType unionType = UnionType.create(types);
 298
 299         final String elName = "lfUnion";
 300         final String int8 = "15";
 301
 302         NormalizedNodeContext normalizedNodeContext = prepareNNC(
 303                 TypeDefinitionAwareCodec.from(unionType).deserialize(int8),
 304                 elName);
 305         nnToXml(normalizedNodeContext, "<" + elName + ">15</" + elName
 306                 + ">");
 307
 308         final String bits = "first second";
 309         normalizedNodeContext = prepareNNC(
 310                 TypeDefinitionAwareCodec.from(unionType).deserialize(bits),
 311                 elName);
 312         nnToXml(normalizedNodeContext, "<" + elName + ">first second</"
 313                 + elName + ">");
 314
 315         final String bool = "true";
 316         normalizedNodeContext = prepareNNC(
 317                 TypeDefinitionAwareCodec.from(unionType).deserialize(bool),
 318                 elName);
 319         nnToXml(normalizedNodeContext, "<" + elName + ">true</" + elName
 320                 + ">");
 321     }
 322
 323     private NormalizedNodeContext prepareNNC(final Object object, final String name) {
 324         final QName cont = QName.create("basic:module", "2013-12-2", "cont");
 325         final QName lf = QName.create("basic:module", "2013-12-2", name);
 326
 327         final DataSchemaNode contSchema = schemaContext.getDataChildByName(cont);
 328
 329         final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> contData = Builders
 330                 .containerBuilder((ContainerSchemaNode) contSchema);
 331
 332         final List<DataSchemaNode> instanceLf = ControllerContext
 333                 .findInstanceDataChildrenByName((DataNodeContainer) contSchema,
 334                         lf.getLocalName());
 335         final DataSchemaNode schemaLf = Iterables.getFirst(instanceLf, null);
 336
 337         contData.withChild(Builders.leafBuilder((LeafSchemaNode) schemaLf)
 338                 .withValue(object).build());
 339
 340         final NormalizedNodeContext testNormalizedNodeContext = new NormalizedNodeContext(
 341                 new InstanceIdentifierContext<DataSchemaNode>(null, contSchema,
 342                         null, schemaContext), contData.build());
 343
 344         return testNormalizedNodeContext;
 345     }
 346
 347     private void nnToXml(
 348             final NormalizedNodeContext normalizedNodeContext,
 349             final String... xmlRepresentation)
 350  throws Exception {
 351         final OutputStream output = new ByteArrayOutputStream();
 352         xmlBodyWriter.writeTo(normalizedNodeContext, null, null, null,
 353                     mediaType, null, output);
 354
 355         for (int i = 0; i < xmlRepresentation.length; i++) {
 356             assertTrue(output.toString().contains(xmlRepresentation[i]));
 357         }
 358     }
 359
 360     private NormalizedNodeContext prepareLeafrefData() {
 361         final QName cont = QName.create("basic:module", "2013-12-2", "cont");
 362         final QName lfBoolean = QName
 363                 .create("basic:module", "2013-12-2", "lfBoolean");
 364         final QName lfLfref = QName.create("basic:module", "2013-12-2", "lfLfref");
 365
 366         final DataSchemaNode contSchema = schemaContext.getDataChildByName(cont);
 367
 368         final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> contData = Builders
 369                 .containerBuilder((ContainerSchemaNode) contSchema);
 370
 371         List<DataSchemaNode> instanceLf = ControllerContext
 372                 .findInstanceDataChildrenByName((DataNodeContainer) contSchema,
 373                         lfBoolean.getLocalName());
 374         DataSchemaNode schemaLf = Iterables.getFirst(instanceLf, null);
 375
 376         contData.withChild(Builders.leafBuilder((LeafSchemaNode) schemaLf)
 377                 .withValue(Boolean.TRUE).build());
 378
 379         instanceLf = ControllerContext.findInstanceDataChildrenByName(
 380                 (DataNodeContainer) contSchema, lfLfref.getLocalName());
 381         schemaLf = Iterables.getFirst(instanceLf, null);
 382
 383         contData.withChild(Builders.leafBuilder((LeafSchemaNode) schemaLf)
 384                 .withValue("true").build());
 385
 386         final NormalizedNodeContext testNormalizedNodeContext = new NormalizedNodeContext(
 387                 new InstanceIdentifierContext<DataSchemaNode>(null, contSchema,
 388                         null, schemaContext), contData.build());
 389
 390         return testNormalizedNodeContext;
 391     }
 392
 393     private NormalizedNodeContext prepareIdrefData(final String prefix,
 394             final boolean valueAsQName) {
 395         final QName cont = QName.create("basic:module", "2013-12-2", "cont");
 396         final QName cont1 = QName.create("basic:module", "2013-12-2", "cont1");
 397         final QName lf11 = QName.create("basic:module", "2013-12-2", "lf11");
 398
 399         final DataSchemaNode contSchema = schemaContext.getDataChildByName(cont);
 400
 401         final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> contData = Builders
 402                 .containerBuilder((ContainerSchemaNode) contSchema);
 403
 404         final DataSchemaNode cont1Schema = ((ContainerSchemaNode) contSchema)
 405                 .getDataChildByName(cont1);
 406
 407         final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> cont1Data = Builders
 408                 .containerBuilder((ContainerSchemaNode) cont1Schema);
 409
 410         Object value = null;
 411         if (valueAsQName) {
 412             value = QName.create("referenced:module", "2013-12-2", "iden");
 413         } else {
 414             value = "no qname value";
 415         }
 416
 417         final List<DataSchemaNode> instanceLf = ControllerContext
 418                 .findInstanceDataChildrenByName(
 419                         (DataNodeContainer) cont1Schema, lf11.getLocalName());
 420         final DataSchemaNode schemaLf = Iterables.getFirst(instanceLf, null);
 421
 422         cont1Data.withChild(Builders.leafBuilder((LeafSchemaNode) schemaLf)
 423                 .withValue(value).build());
 424
 425         contData.withChild(cont1Data.build());
 426
 427         final NormalizedNodeContext testNormalizedNodeContext = new NormalizedNodeContext(
 428                 new InstanceIdentifierContext<DataSchemaNode>(null, contSchema,
 429                         null, schemaContext), contData.build());
 430         return testNormalizedNodeContext;
 431     }
 432
 433     @Override
 434     protected MediaType getMediaType() {
 435         // TODO Auto-generated method stub
 436         return null;
 437     }
 438 }