2 * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
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
8 package org.opendaylight.controller.sal.restconf.impl.nn.to.xml.test;
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;
58 public class NnToXmlTest extends AbstractBodyReaderTest {
60 private final NormalizedNodeXmlBodyWriter xmlBodyWriter;
61 private static SchemaContext schemaContext;
63 public NnToXmlTest() throws NoSuchFieldException, SecurityException {
65 xmlBodyWriter = new NormalizedNodeXmlBodyWriter();
69 public static void initialization() {
70 schemaContext = schemaContextLoader("/nn-to-xml/yang", schemaContext);
71 controllerContext.setSchemas(schemaContext);
75 public void nnAsYangIdentityrefToXMLTest() throws Exception {
76 final NormalizedNodeContext normalizedNodeContext = prepareIdrefData(null,
78 nnToXml(normalizedNodeContext,
79 "<lf11 xmlns:x=\"referenced:module\">x:iden</lf11>");
83 public void nnAsYangIdentityrefWithQNamePrefixToXMLTest() throws Exception {
84 final NormalizedNodeContext normalizedNodeContext = prepareIdrefData(
86 nnToXml(normalizedNodeContext, "<lf11 xmlns",
87 "=\"referenced:module\">", ":iden</lf11>");
91 public void nnAsYangIdentityrefWithPrefixToXMLTest() throws Exception {
92 final NormalizedNodeContext normalizedNodeContext = prepareIdrefData(
94 nnToXml(normalizedNodeContext, "<lf11>no qname value</lf11>");
98 public void nnAsYangLeafrefWithPrefixToXMLTest() throws Exception {
99 final NormalizedNodeContext normalizedNodeContext = prepareLeafrefData();
100 nnToXml(normalizedNodeContext, "<lfBoolean>true</lfBoolean>",
101 "<lfLfref>true</lfLfref>");
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>");
113 public void nnAsYangInt8ToXmlTest() throws Exception {
114 final String elName = "lfInt8";
116 final NormalizedNodeContext normalizedNodeContext = prepareNNC(
117 TypeDefinitionAwareCodec.from(Int8.getInstance()).deserialize(
119 nnToXml(normalizedNodeContext, "<" + elName + ">14</" + elName
124 public void nnAsYangInt16ToXmlTest() throws Exception {
125 final String elName = "lfInt16";
127 final NormalizedNodeContext normalizedNodeContext = prepareNNC(
128 TypeDefinitionAwareCodec.from(Int16.getInstance()).deserialize(
130 nnToXml(normalizedNodeContext, "<" + elName + ">3000</" + elName
135 public void nnAsYangInt32ToXmlTest() throws Exception {
136 final String elName = "lfInt32";
138 final NormalizedNodeContext normalizedNodeContext = prepareNNC(
139 TypeDefinitionAwareCodec.from(Int32.getInstance()).deserialize(
141 nnToXml(normalizedNodeContext, "<" + elName + ">201234</"
146 public void nnAsYangInt64ToXmlTest() throws Exception {
147 final String elName = "lfInt64";
149 final NormalizedNodeContext normalizedNodeContext = prepareNNC(
150 TypeDefinitionAwareCodec.from(Int64.getInstance()).deserialize(
151 "5123456789"), elName);
152 nnToXml(normalizedNodeContext, "<" + elName + ">5123456789</"
157 public void nnAsYangUint8ToXmlTest() throws Exception {
158 final String elName = "lfUint8";
160 final NormalizedNodeContext normalizedNodeContext = prepareNNC(
161 TypeDefinitionAwareCodec.from(Uint8.getInstance()).deserialize(
163 nnToXml(normalizedNodeContext, "<" + elName + ">200</" + elName
168 public void snAsYangUint16ToXmlTest() throws Exception {
169 final String elName = "lfUint16";
171 final NormalizedNodeContext normalizedNodeContext = prepareNNC(
172 TypeDefinitionAwareCodec.from(Uint16.getInstance())
173 .deserialize("4000"), elName);
174 nnToXml(normalizedNodeContext, "<" + elName + ">4000</" + elName
179 public void nnAsYangUint32ToXmlTest() throws Exception {
180 final String elName = "lfUint32";
182 final NormalizedNodeContext normalizedNodeContext = prepareNNC(
183 TypeDefinitionAwareCodec.from(Uint32.getInstance())
184 .deserialize("4123456789"), elName);
185 nnToXml(normalizedNodeContext, "<" + elName + ">4123456789</"
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</"
200 public void nnAsYangBinaryToXmlTest() throws Exception {
201 final String elName = "lfBinary";
202 final NormalizedNodeContext normalizedNodeContext = prepareNNC(
203 TypeDefinitionAwareCodec
204 .from(BinaryType.getInstance())
206 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567"),
209 normalizedNodeContext,
212 + ">ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567</"
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(
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</"
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);
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</"
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
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</"
273 normalizedNodeContext = prepareNNC(
274 TypeDefinitionAwareCodec.from(BooleanType.getInstance())
275 .deserialize("true"), elName);
276 nnToXml(normalizedNodeContext, "<" + elName + ">true</" + elName
281 public void nnAsYangUnionToXmlTest() throws Exception {
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(
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);
298 final String elName = "lfUnion";
299 final String int8 = "15";
301 NormalizedNodeContext normalizedNodeContext = prepareNNC(
302 TypeDefinitionAwareCodec.from(unionType).deserialize(int8),
304 nnToXml(normalizedNodeContext, "<" + elName + ">15</" + elName
307 final String bits = "first second";
308 normalizedNodeContext = prepareNNC(
309 TypeDefinitionAwareCodec.from(unionType).deserialize(bits),
311 nnToXml(normalizedNodeContext, "<" + elName + ">first second</"
314 final String bool = "str";
315 normalizedNodeContext = prepareNNC(
316 TypeDefinitionAwareCodec.from(unionType).deserialize(bool),
318 nnToXml(normalizedNodeContext, "<" + elName + ">str</" + elName
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);
326 final DataSchemaNode contSchema = schemaContext.getDataChildByName(cont);
328 final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> contData = Builders
329 .containerBuilder((ContainerSchemaNode) contSchema);
331 final List<DataSchemaNode> instanceLf = ControllerContext
332 .findInstanceDataChildrenByName((DataNodeContainer) contSchema,
334 final DataSchemaNode schemaLf = Iterables.getFirst(instanceLf, null);
336 contData.withChild(Builders.leafBuilder((LeafSchemaNode) schemaLf)
337 .withValue(object).build());
339 final NormalizedNodeContext testNormalizedNodeContext = new NormalizedNodeContext(
340 new InstanceIdentifierContext<DataSchemaNode>(null, contSchema,
341 null, schemaContext), contData.build());
343 return testNormalizedNodeContext;
346 private void nnToXml(
347 final NormalizedNodeContext normalizedNodeContext,
348 final String... xmlRepresentation)
350 final OutputStream output = new ByteArrayOutputStream();
351 xmlBodyWriter.writeTo(normalizedNodeContext, null, null, null,
352 mediaType, null, output);
354 for (int i = 0; i < xmlRepresentation.length; i++) {
355 assertTrue(output.toString().contains(xmlRepresentation[i]));
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");
365 final DataSchemaNode contSchema = schemaContext.getDataChildByName(cont);
367 final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> contData = Builders
368 .containerBuilder((ContainerSchemaNode) contSchema);
370 List<DataSchemaNode> instanceLf = ControllerContext
371 .findInstanceDataChildrenByName((DataNodeContainer) contSchema,
372 lfBoolean.getLocalName());
373 DataSchemaNode schemaLf = Iterables.getFirst(instanceLf, null);
375 contData.withChild(Builders.leafBuilder((LeafSchemaNode) schemaLf)
376 .withValue(Boolean.TRUE).build());
378 instanceLf = ControllerContext.findInstanceDataChildrenByName(
379 (DataNodeContainer) contSchema, lfLfref.getLocalName());
380 schemaLf = Iterables.getFirst(instanceLf, null);
382 contData.withChild(Builders.leafBuilder((LeafSchemaNode) schemaLf)
383 .withValue("true").build());
385 final NormalizedNodeContext testNormalizedNodeContext = new NormalizedNodeContext(
386 new InstanceIdentifierContext<DataSchemaNode>(null, contSchema,
387 null, schemaContext), contData.build());
389 return testNormalizedNodeContext;
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");
398 final DataSchemaNode contSchema = schemaContext.getDataChildByName(cont);
400 final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> contData = Builders
401 .containerBuilder((ContainerSchemaNode) contSchema);
403 final DataSchemaNode cont1Schema = ((ContainerSchemaNode) contSchema)
404 .getDataChildByName(cont1);
406 final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> cont1Data = Builders
407 .containerBuilder((ContainerSchemaNode) cont1Schema);
411 value = QName.create("referenced:module", "2013-12-2", "iden");
413 value = "no qname value";
416 final List<DataSchemaNode> instanceLf = ControllerContext
417 .findInstanceDataChildrenByName(
418 (DataNodeContainer) cont1Schema, lf11.getLocalName());
419 final DataSchemaNode schemaLf = Iterables.getFirst(instanceLf, null);
421 cont1Data.withChild(Builders.leafBuilder((LeafSchemaNode) schemaLf)
422 .withValue(value).build());
424 contData.withChild(cont1Data.build());
426 final NormalizedNodeContext testNormalizedNodeContext = new NormalizedNodeContext(
427 new InstanceIdentifierContext<DataSchemaNode>(null, contSchema,
428 null, schemaContext), contData.build());
429 return testNormalizedNodeContext;
433 protected MediaType getMediaType() {
434 // TODO Auto-generated method stub