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