From bec0511bd378c069a2f51545736064a9821e44a7 Mon Sep 17 00:00:00 2001 From: Jakub Toth Date: Mon, 1 Jun 2015 10:15:54 +0200 Subject: [PATCH] Bug 2358 - Remove tests cnsn to xml and add tests nn to xml Tests of codecs are included in codecs yangtools yang-data-codec-gson and yang-data-impl but we test codec on input data and also with presentation of Rest path. * remove CnSnToXmlTest test * add NnToXmlTest to nn/to/xml/test/ * positive tests for basic data types Change-Id: Iac408dc8ce25c8d9c46a21863733b30390ea8c34 Signed-off-by: Jakub Toth --- .../impl/cnsn/to/xml/test/CnSnToXmlTest.java | 25 - .../impl/nn/to/xml/test/NnToXmlTest.java | 437 ++++++++++++++++++ 2 files changed, 437 insertions(+), 25 deletions(-) delete mode 100644 opendaylight/md-sal/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/cnsn/to/xml/test/CnSnToXmlTest.java create mode 100644 opendaylight/md-sal/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/nn/to/xml/test/NnToXmlTest.java diff --git a/opendaylight/md-sal/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/cnsn/to/xml/test/CnSnToXmlTest.java b/opendaylight/md-sal/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/cnsn/to/xml/test/CnSnToXmlTest.java deleted file mode 100644 index 24987c5667..0000000000 --- a/opendaylight/md-sal/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/cnsn/to/xml/test/CnSnToXmlTest.java +++ /dev/null @@ -1,25 +0,0 @@ -/* - * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ -package org.opendaylight.controller.sal.restconf.impl.cnsn.to.xml.test; - -import org.junit.BeforeClass; -import org.opendaylight.controller.sal.restconf.impl.test.YangAndXmlAndDataSchemaLoader; - -/** - * - * CnSn = Composite node and Simple node data structure Class contains test of serializing simple nodes data values - * according data types from YANG schema to XML file - * - */ -public class CnSnToXmlTest extends YangAndXmlAndDataSchemaLoader { - @BeforeClass - public static void initialization() { - dataLoad("/cnsn-to-xml/yang", 2, "basic-module", "cont"); - } - -} \ No newline at end of file diff --git a/opendaylight/md-sal/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/nn/to/xml/test/NnToXmlTest.java b/opendaylight/md-sal/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/nn/to/xml/test/NnToXmlTest.java new file mode 100644 index 0000000000..c9d0c58d6b --- /dev/null +++ b/opendaylight/md-sal/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/nn/to/xml/test/NnToXmlTest.java @@ -0,0 +1,437 @@ +/* + * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.controller.sal.restconf.impl.nn.to.xml.test; + +import static org.junit.Assert.assertTrue; +import com.google.common.base.Optional; +import com.google.common.collect.Iterables; +import com.google.common.collect.Lists; +import java.io.ByteArrayOutputStream; +import java.io.OutputStream; +import java.util.List; +import javax.ws.rs.core.MediaType; +import org.junit.BeforeClass; +import org.junit.Test; +import org.mockito.Mockito; +import org.opendaylight.controller.sal.rest.impl.NormalizedNodeXmlBodyWriter; +import org.opendaylight.controller.sal.rest.impl.test.providers.AbstractBodyReaderTest; +import org.opendaylight.controller.sal.restconf.impl.ControllerContext; +import org.opendaylight.controller.sal.restconf.impl.InstanceIdentifierContext; +import org.opendaylight.controller.sal.restconf.impl.NormalizedNodeContext; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier; +import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode; +import org.opendaylight.yangtools.yang.data.impl.codec.TypeDefinitionAwareCodec; +import org.opendaylight.yangtools.yang.data.impl.schema.Builders; +import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder; +import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode; +import org.opendaylight.yangtools.yang.model.api.DataNodeContainer; +import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; +import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode; +import org.opendaylight.yangtools.yang.model.api.SchemaContext; +import org.opendaylight.yangtools.yang.model.api.SchemaPath; +import org.opendaylight.yangtools.yang.model.api.TypeDefinition; +import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition; +import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition; +import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair; +import org.opendaylight.yangtools.yang.model.util.BinaryType; +import org.opendaylight.yangtools.yang.model.util.BitsType; +import org.opendaylight.yangtools.yang.model.util.BooleanType; +import org.opendaylight.yangtools.yang.model.util.EmptyType; +import org.opendaylight.yangtools.yang.model.util.EnumerationType; +import org.opendaylight.yangtools.yang.model.util.Int16; +import org.opendaylight.yangtools.yang.model.util.Int32; +import org.opendaylight.yangtools.yang.model.util.Int64; +import org.opendaylight.yangtools.yang.model.util.Int8; +import org.opendaylight.yangtools.yang.model.util.StringType; +import org.opendaylight.yangtools.yang.model.util.Uint16; +import org.opendaylight.yangtools.yang.model.util.Uint32; +import org.opendaylight.yangtools.yang.model.util.Uint64; +import org.opendaylight.yangtools.yang.model.util.Uint8; +import org.opendaylight.yangtools.yang.model.util.UnionType; + +public class NnToXmlTest extends AbstractBodyReaderTest { + + private final NormalizedNodeXmlBodyWriter xmlBodyWriter; + private static SchemaContext schemaContext; + + public NnToXmlTest() throws NoSuchFieldException, SecurityException { + super(); + xmlBodyWriter = new NormalizedNodeXmlBodyWriter(); + } + + @BeforeClass + public static void initialization() { + schemaContext = schemaContextLoader("/nn-to-xml/yang", schemaContext); + controllerContext.setSchemas(schemaContext); + } + + @Test + public void nnAsYangIdentityrefToXMLTest() throws Exception { + final NormalizedNodeContext normalizedNodeContext = prepareIdrefData(null, + true); + nnToXml(normalizedNodeContext, + "x:iden"); + } + + @Test + public void nnAsYangIdentityrefWithQNamePrefixToXMLTest() throws Exception { + final NormalizedNodeContext normalizedNodeContext = prepareIdrefData( + "prefix", true); + nnToXml(normalizedNodeContext, "", ":iden"); + } + + @Test + public void nnAsYangIdentityrefWithPrefixToXMLTest() throws Exception { + final NormalizedNodeContext normalizedNodeContext = prepareIdrefData( + "prefix", false); + nnToXml(normalizedNodeContext, "no qname value"); + } + + @Test + public void nnAsYangLeafrefWithPrefixToXMLTest() throws Exception { + final NormalizedNodeContext normalizedNodeContext = prepareLeafrefData(); + nnToXml(normalizedNodeContext, "true", + "true"); + } + + @Test + public void nnAsYangStringToXmlTest() throws Exception { + final NormalizedNodeContext normalizedNodeContext = prepareNNC( + TypeDefinitionAwareCodec.from(StringType.getInstance()) + .deserialize("lfStr value"), "lfStr"); + nnToXml(normalizedNodeContext, "lfStr value"); + } + + @Test + public void nnAsYangInt8ToXmlTest() throws Exception { + final String elName = "lfInt8"; + + final NormalizedNodeContext normalizedNodeContext = prepareNNC( + TypeDefinitionAwareCodec.from(Int8.getInstance()).deserialize( + "14"), elName); + nnToXml(normalizedNodeContext, "<" + elName + ">14"); + } + + @Test + public void nnAsYangInt16ToXmlTest() throws Exception { + final String elName = "lfInt16"; + + final NormalizedNodeContext normalizedNodeContext = prepareNNC( + TypeDefinitionAwareCodec.from(Int16.getInstance()).deserialize( + "3000"), elName); + nnToXml(normalizedNodeContext, "<" + elName + ">3000"); + } + + @Test + public void nnAsYangInt32ToXmlTest() throws Exception { + final String elName = "lfInt32"; + + final NormalizedNodeContext normalizedNodeContext = prepareNNC( + TypeDefinitionAwareCodec.from(Int32.getInstance()).deserialize( + "201234"), elName); + nnToXml(normalizedNodeContext, "<" + elName + ">201234"); + } + + @Test + public void nnAsYangInt64ToXmlTest() throws Exception { + final String elName = "lfInt64"; + + final NormalizedNodeContext normalizedNodeContext = prepareNNC( + TypeDefinitionAwareCodec.from(Int64.getInstance()).deserialize( + "5123456789"), elName); + nnToXml(normalizedNodeContext, "<" + elName + ">5123456789"); + } + + @Test + public void nnAsYangUint8ToXmlTest() throws Exception { + final String elName = "lfUint8"; + + final NormalizedNodeContext normalizedNodeContext = prepareNNC( + TypeDefinitionAwareCodec.from(Uint8.getInstance()).deserialize( + "200"), elName); + nnToXml(normalizedNodeContext, "<" + elName + ">200"); + } + + @Test + public void snAsYangUint16ToXmlTest() throws Exception { + final String elName = "lfUint16"; + + final NormalizedNodeContext normalizedNodeContext = prepareNNC( + TypeDefinitionAwareCodec.from(Uint16.getInstance()) + .deserialize("4000"), elName); + nnToXml(normalizedNodeContext, "<" + elName + ">4000"); + } + + @Test + public void nnAsYangUint32ToXmlTest() throws Exception { + final String elName = "lfUint32"; + + final NormalizedNodeContext normalizedNodeContext = prepareNNC( + TypeDefinitionAwareCodec.from(Uint32.getInstance()) + .deserialize("4123456789"), elName); + nnToXml(normalizedNodeContext, "<" + elName + ">4123456789"); + } + + @Test + public void snAsYangUint64ToXmlTest() throws Exception { + final String elName = "lfUint64"; + final NormalizedNodeContext normalizedNodeContext = prepareNNC( + TypeDefinitionAwareCodec.from(Uint64.getInstance()) + .deserialize("5123456789"), elName); + nnToXml(normalizedNodeContext, "<" + elName + ">5123456789"); + } + + @Test + public void nnAsYangBinaryToXmlTest() throws Exception { + final String elName = "lfBinary"; + final NormalizedNodeContext normalizedNodeContext = prepareNNC( + TypeDefinitionAwareCodec + .from(BinaryType.getInstance()) + .deserialize( + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567"), + elName); + nnToXml( + normalizedNodeContext, + "<" + + elName + + ">ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567"); + } + + @Test + public void nnAsYangBitsToXmlTest() throws Exception { + final BitsTypeDefinition.Bit mockBit1 = Mockito + .mock(BitsTypeDefinition.Bit.class); + Mockito.when(mockBit1.getName()).thenReturn("one"); + final BitsTypeDefinition.Bit mockBit2 = Mockito + .mock(BitsTypeDefinition.Bit.class); + Mockito.when(mockBit2.getName()).thenReturn("two"); + final List bitList = Lists.newArrayList( + mockBit1, mockBit2); + + final String elName = "lfBits"; + final NormalizedNodeContext normalizedNodeContext = prepareNNC( + TypeDefinitionAwareCodec + .from(BitsType.create(Mockito.mock(SchemaPath.class), + bitList)).deserialize("one two"), elName); + nnToXml(normalizedNodeContext, "<" + elName + ">one two"); + } + + @Test + public void nnAsYangEnumerationToXmlTest() throws Exception { + final EnumTypeDefinition.EnumPair mockEnum = Mockito + .mock(EnumTypeDefinition.EnumPair.class); + Mockito.when(mockEnum.getName()).thenReturn("enum2"); + final List enumList = Lists.newArrayList(mockEnum); + + final String elName = "lfEnumeration"; + final NormalizedNodeContext normalizedNodeContext = prepareNNC( + TypeDefinitionAwareCodec + .from(EnumerationType.create( + Mockito.mock(SchemaPath.class), enumList, + Optional. absent())) + .deserialize("enum2"), elName); + nnToXml(normalizedNodeContext, "<" + elName + ">enum2"); + } + + @Test + public void nnAsYangEmptyToXmlTest() throws Exception { + final String elName = "lfEmpty"; + final NormalizedNodeContext normalizedNodeContext = prepareNNC( + TypeDefinitionAwareCodec.from(EmptyType.getInstance()) + .deserialize(null), elName); + nnToXml(normalizedNodeContext, "<" + elName + ">"); + } + + @Test + public void nnAsYangBooleanToXmlTest() throws Exception { + final String elName = "lfBoolean"; + NormalizedNodeContext normalizedNodeContext = prepareNNC( + TypeDefinitionAwareCodec.from(BooleanType.getInstance()) + .deserialize("str"), elName); + nnToXml(normalizedNodeContext, "<" + elName + ">false"); + + normalizedNodeContext = prepareNNC( + TypeDefinitionAwareCodec.from(BooleanType.getInstance()) + .deserialize("true"), elName); + nnToXml(normalizedNodeContext, "<" + elName + ">true"); + } + + @Test + public void nnAsYangUnionToXmlTest() throws Exception { + + final BitsTypeDefinition.Bit mockBit1 = Mockito + .mock(BitsTypeDefinition.Bit.class); + Mockito.when(mockBit1.getName()).thenReturn("first"); + final BitsTypeDefinition.Bit mockBit2 = Mockito + .mock(BitsTypeDefinition.Bit.class); + Mockito.when(mockBit2.getName()).thenReturn("second"); + final List bitList = Lists.newArrayList( + mockBit1, mockBit2); + + final List> types = Lists + .> newArrayList(Int8.getInstance(), BitsType + .create(Mockito.mock(SchemaPath.class), bitList), + BooleanType.getInstance()); + final UnionType unionType = UnionType.create(types); + + final String elName = "lfUnion"; + final String int8 = "15"; + + NormalizedNodeContext normalizedNodeContext = prepareNNC( + TypeDefinitionAwareCodec.from(unionType).deserialize(int8), + elName); + nnToXml(normalizedNodeContext, "<" + elName + ">15"); + + final String bits = "first second"; + normalizedNodeContext = prepareNNC( + TypeDefinitionAwareCodec.from(unionType).deserialize(bits), + elName); + nnToXml(normalizedNodeContext, "<" + elName + ">first second"); + + final String bool = "str"; + normalizedNodeContext = prepareNNC( + TypeDefinitionAwareCodec.from(unionType).deserialize(bool), + elName); + nnToXml(normalizedNodeContext, "<" + elName + ">str"); + } + + private NormalizedNodeContext prepareNNC(final Object object, final String name) { + final QName cont = QName.create("basic:module", "2013-12-2", "cont"); + final QName lf = QName.create("basic:module", "2013-12-2", name); + + final DataSchemaNode contSchema = schemaContext.getDataChildByName(cont); + + final DataContainerNodeAttrBuilder contData = Builders + .containerBuilder((ContainerSchemaNode) contSchema); + + final List instanceLf = ControllerContext + .findInstanceDataChildrenByName((DataNodeContainer) contSchema, + lf.getLocalName()); + final DataSchemaNode schemaLf = Iterables.getFirst(instanceLf, null); + + contData.withChild(Builders.leafBuilder((LeafSchemaNode) schemaLf) + .withValue(object).build()); + + final NormalizedNodeContext testNormalizedNodeContext = new NormalizedNodeContext( + new InstanceIdentifierContext(null, contSchema, + null, schemaContext), contData.build()); + + return testNormalizedNodeContext; + } + + private void nnToXml( + final NormalizedNodeContext normalizedNodeContext, + final String... xmlRepresentation) + throws Exception { + final OutputStream output = new ByteArrayOutputStream(); + xmlBodyWriter.writeTo(normalizedNodeContext, null, null, null, + mediaType, null, output); + + for (int i = 0; i < xmlRepresentation.length; i++) { + assertTrue(output.toString().contains(xmlRepresentation[i])); + } + } + + private NormalizedNodeContext prepareLeafrefData() { + final QName cont = QName.create("basic:module", "2013-12-2", "cont"); + final QName lfBoolean = QName + .create("basic:module", "2013-12-2", "lfBoolean"); + final QName lfLfref = QName.create("basic:module", "2013-12-2", "lfLfref"); + + final DataSchemaNode contSchema = schemaContext.getDataChildByName(cont); + + final DataContainerNodeAttrBuilder contData = Builders + .containerBuilder((ContainerSchemaNode) contSchema); + + List instanceLf = ControllerContext + .findInstanceDataChildrenByName((DataNodeContainer) contSchema, + lfBoolean.getLocalName()); + DataSchemaNode schemaLf = Iterables.getFirst(instanceLf, null); + + contData.withChild(Builders.leafBuilder((LeafSchemaNode) schemaLf) + .withValue(Boolean.TRUE).build()); + + instanceLf = ControllerContext.findInstanceDataChildrenByName( + (DataNodeContainer) contSchema, lfLfref.getLocalName()); + schemaLf = Iterables.getFirst(instanceLf, null); + + contData.withChild(Builders.leafBuilder((LeafSchemaNode) schemaLf) + .withValue("true").build()); + + final NormalizedNodeContext testNormalizedNodeContext = new NormalizedNodeContext( + new InstanceIdentifierContext(null, contSchema, + null, schemaContext), contData.build()); + + return testNormalizedNodeContext; + } + + private NormalizedNodeContext prepareIdrefData(final String prefix, + final boolean valueAsQName) { + final QName cont = QName.create("basic:module", "2013-12-2", "cont"); + final QName cont1 = QName.create("basic:module", "2013-12-2", "cont1"); + final QName lf11 = QName.create("basic:module", "2013-12-2", "lf11"); + + final DataSchemaNode contSchema = schemaContext.getDataChildByName(cont); + + final DataContainerNodeAttrBuilder contData = Builders + .containerBuilder((ContainerSchemaNode) contSchema); + + final DataSchemaNode cont1Schema = ((ContainerSchemaNode) contSchema) + .getDataChildByName(cont1); + + final DataContainerNodeAttrBuilder cont1Data = Builders + .containerBuilder((ContainerSchemaNode) cont1Schema); + + Object value = null; + if (valueAsQName) { + value = QName.create("referenced:module", "2013-12-2", "iden"); + } else { + value = "no qname value"; + } + + final List instanceLf = ControllerContext + .findInstanceDataChildrenByName( + (DataNodeContainer) cont1Schema, lf11.getLocalName()); + final DataSchemaNode schemaLf = Iterables.getFirst(instanceLf, null); + + cont1Data.withChild(Builders.leafBuilder((LeafSchemaNode) schemaLf) + .withValue(value).build()); + + contData.withChild(cont1Data.build()); + + final NormalizedNodeContext testNormalizedNodeContext = new NormalizedNodeContext( + new InstanceIdentifierContext(null, contSchema, + null, schemaContext), contData.build()); + return testNormalizedNodeContext; + } + + @Override + protected MediaType getMediaType() { + // TODO Auto-generated method stub + return null; + } +} -- 2.36.6