From: Jakub Toth Date: Wed, 5 Apr 2017 13:36:11 +0000 (+0200) Subject: Bug 8151 - RpcActionGenHelper - Increase test coverage X-Git-Tag: release/carbon~40 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=commitdiff_plain;h=d9596e6147f08c7c8fb64761755343010bb37e5a;p=mdsal.git Bug 8151 - RpcActionGenHelper - Increase test coverage Change-Id: I7e8bd583ad97a562d647a697733fde42fe30a77b Signed-off-by: Jakub Toth --- diff --git a/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/RpcActionGenHelper.java b/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/RpcActionGenHelper.java index cfed2efeab..cf65e3fabf 100644 --- a/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/RpcActionGenHelper.java +++ b/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/RpcActionGenHelper.java @@ -222,10 +222,6 @@ public final class RpcActionGenHelper { parentType.addImplementsType(augmentable(parentType)); annotateDeprecatedIfNecessary(parent.getStatus(), parentType); - GenHelperUtil.resolveDataSchemaNodes(module, basePackageName, parentType, parentType, - ((ContainerSchemaNode) parent).getChildNodes(), genCtx, schemaContext, verboseClassComments, - genTypeBuilders, typeProvider); - operationMethod.addParameter(parameterizedTypeFor(INSTANCE_IDENTIFIER, parentType), "ii"); if (parent instanceof ListSchemaNode) { @@ -237,6 +233,9 @@ public final class RpcActionGenHelper { interfaceBuilder.addImplementsType(parameterizedTypeFor(LIST_ACTION, parentType, inType, outType)); } else { //Action + GenHelperUtil.resolveDataSchemaNodes(module, basePackageName, parentType, parentType, + ((ContainerSchemaNode) parent).getChildNodes(), genCtx, schemaContext, verboseClassComments, + genTypeBuilders, typeProvider); operationMethod.addParameter(parameterizedTypeFor(INSTANCE_IDENTIFIER, parentType), "ii"); interfaceBuilder.addImplementsType(parameterizedTypeFor(ACTION, parentType, inType, outType)); } diff --git a/binding2/mdsal-binding2-generator-impl/src/test/java/org/opendaylight/mdsal/binding/javav2/generator/impl/RpcActionGenHelperTest.java b/binding2/mdsal-binding2-generator-impl/src/test/java/org/opendaylight/mdsal/binding/javav2/generator/impl/RpcActionGenHelperTest.java new file mode 100644 index 0000000000..43a538dc8e --- /dev/null +++ b/binding2/mdsal-binding2-generator-impl/src/test/java/org/opendaylight/mdsal/binding/javav2/generator/impl/RpcActionGenHelperTest.java @@ -0,0 +1,344 @@ +/* + * Copyright (c) 2017 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.mdsal.binding.javav2.generator.impl; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import com.google.common.base.Optional; +import java.lang.reflect.Constructor; +import java.lang.reflect.Field; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import org.junit.Test; +import org.opendaylight.mdsal.binding.javav2.generator.spi.TypeProvider; +import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTypeBuilder; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.ActionDefinition; +import org.opendaylight.yangtools.yang.model.api.ActionNodeContainer; +import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode; +import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; +import org.opendaylight.yangtools.yang.model.api.ListSchemaNode; +import org.opendaylight.yangtools.yang.model.api.Module; +import org.opendaylight.yangtools.yang.model.api.RpcDefinition; +import org.opendaylight.yangtools.yang.model.api.SchemaContext; +import org.opendaylight.yangtools.yang.model.api.SchemaNode; +import org.opendaylight.yangtools.yang.model.api.SchemaPath; +import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode; + +public class RpcActionGenHelperTest { + + @SuppressWarnings("unchecked") + @Test(expected = UnsupportedOperationException.class) + public void constructorTest() throws Throwable { + final Constructor constructor = + (Constructor) RpcActionGenHelper.class.getDeclaredConstructors()[0]; + constructor.setAccessible(true); + final Object[] objs = {}; + try { + constructor.newInstance(objs); + } catch (final Exception e) { + throw e.getCause(); + } + } + + @SuppressWarnings({ "rawtypes", "unchecked" }) + @Test + public void getRoutingContextAbsentTest() throws Exception { + final Class[] parameterTypes = { DataSchemaNode.class }; + final Method generate = RpcActionGenHelper.class.getDeclaredMethod("getRoutingContext", parameterTypes); + assertNotNull(generate); + generate.setAccessible(true); + final DataSchemaNode dataSchemaNode = mock(DataSchemaNode.class); + final List unknownSchemaNodes = new ArrayList<>(); + when(dataSchemaNode.getUnknownSchemaNodes()).thenReturn(unknownSchemaNodes); + + final Object[] args = { dataSchemaNode }; + final Optional result = (Optional) generate.invoke(RpcActionGenHelper.class, args); + assertNotNull(result); + assertTrue(!result.isPresent()); + } + + @SuppressWarnings({ "rawtypes", "unchecked" }) + @Test + public void getRoutingContextTest() throws Exception { + final Class[] parameterTypes = { DataSchemaNode.class }; + final Method generate = RpcActionGenHelper.class.getDeclaredMethod("getRoutingContext", parameterTypes); + assertNotNull(generate); + generate.setAccessible(true); + + final DataSchemaNode dataSchemaNode = mock(DataSchemaNode.class); + final List unknownSchemaNodes = new ArrayList<>(); + final Field contextRef = RpcActionGenHelper.class.getDeclaredField("CONTEXT_REFERENCE"); + contextRef.setAccessible(true); + final QName nodeType = (QName) contextRef.get(RpcActionGenHelper.class); + final UnknownSchemaNode unknownSchemaNode = mock(UnknownSchemaNode.class); + when(unknownSchemaNode.getNodeType()).thenReturn(nodeType); + final QName qname = QName.create("test", "2017-05-04", "unknown"); + when(unknownSchemaNode.getQName()).thenReturn(qname); + unknownSchemaNodes.add(unknownSchemaNode); + when(dataSchemaNode.getUnknownSchemaNodes()).thenReturn(unknownSchemaNodes); + + final Object[] args = { dataSchemaNode }; + final Optional result = (Optional) generate.invoke(RpcActionGenHelper.class, args); + assertNotNull(result); + assertTrue(result.isPresent()); + assertEquals(qname, result.get()); + } + + @Test + public void actionMethodsToGenTypeConainerAsParentTest() throws Exception { + actionMethodsToGenType(ContainerSchemaNode.class, false); + } + + @Test + public void actionMethodsToGenTypeListAsParentTest() throws Exception { + actionMethodsToGenType(ListSchemaNode.class, false); + } + + @SuppressWarnings("rawtypes") + @Test + public void rpcMethodsToGenTypeNullRpcsTest() throws Exception { + final Class[] parameterTypes = + { Module.class, Map.class, SchemaContext.class, boolean.class, Map.class, TypeProvider.class }; + final Method generate = RpcActionGenHelper.class.getDeclaredMethod("rpcMethodsToGenType", parameterTypes); + assertNotNull(generate); + generate.setAccessible(true); + + final QName rpcQName = QName.create("test.rpc", "2017-05-04", "rpc-test"); + + final Module module = mock(Module.class); + when(module.getName()).thenReturn("module-name"); + when(module.getRevision()).thenReturn(rpcQName.getRevision()); + when(module.getNamespace()).thenReturn(rpcQName.getNamespace()); + when(module.getRpcs()).thenReturn(null); + + final Map genCtx = new HashMap<>(); + final SchemaContext schemaContext = mock(SchemaContext.class); + final boolean verboseClassComments = false; + final Map> genTypeBuilders = new HashMap<>(); + final TypeProvider typeProvider = mock(TypeProvider.class); + + final Object[] args = { module, genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider }; + + try { + generate.invoke(RpcActionGenHelper.class, args); + fail(); + } catch (final Exception e) { + assertNotNull(e); + assertTrue(e instanceof InvocationTargetException); + final Throwable cause = e.getCause(); + assertNotNull(cause); + assertTrue(cause instanceof IllegalStateException); + } + } + + @SuppressWarnings({ "rawtypes", "unchecked" }) + @Test + public void rpcMethodsToGenTypeEmptyRpcsTest() throws Exception { + final Class[] parameterTypes = + { Module.class, Map.class, SchemaContext.class, boolean.class, Map.class, TypeProvider.class }; + final Method generate = RpcActionGenHelper.class.getDeclaredMethod("rpcMethodsToGenType", parameterTypes); + assertNotNull(generate); + generate.setAccessible(true); + + final QName rpcQName = QName.create("test.rpc", "2017-05-04", "rpc-test"); + + final Module module = mock(Module.class); + when(module.getName()).thenReturn("module-name"); + when(module.getRevision()).thenReturn(rpcQName.getRevision()); + when(module.getNamespace()).thenReturn(rpcQName.getNamespace()); + final Set rpcs = new HashSet<>(); + when(module.getRpcs()).thenReturn(rpcs); + + final Map genCtx = new HashMap<>(); + final SchemaContext schemaContext = mock(SchemaContext.class); + final boolean verboseClassComments = false; + final Map> genTypeBuilders = new HashMap<>(); + final TypeProvider typeProvider = mock(TypeProvider.class); + + final Object[] args = { module, genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider }; + final Map result = + (Map) generate.invoke(RpcActionGenHelper.class, args); + assertNotNull(result); + } + + @Test + public void rpcMethodsToGenTypeRoutedRpcTest() throws Exception { + actionMethodsToGenType(ContainerSchemaNode.class, true); + } + + @SuppressWarnings({ "rawtypes", "unchecked" }) + @Test + public void rpcMethodsToGenTypeRpcTest() throws Exception { + final Class[] parameterTypes = + { Module.class, Map.class, SchemaContext.class, boolean.class, Map.class, TypeProvider.class }; + final Method generate = RpcActionGenHelper.class.getDeclaredMethod("rpcMethodsToGenType", parameterTypes); + assertNotNull(generate); + generate.setAccessible(true); + + final QName rpcQName = QName.create("test.rpc", "2017-05-04", "rpc-test"); + + final ContainerSchemaNode rpcParent = mock(ContainerSchemaNode.class); + final QName rpcParentQName = QName.create(rpcQName, "rpc-parent"); + when(rpcParent.getQName()).thenReturn(rpcParentQName); + + final Module module = mock(Module.class); + when(module.getName()).thenReturn("module-name"); + when(module.getRevision()).thenReturn(rpcQName.getRevision()); + when(module.getNamespace()).thenReturn(rpcQName.getNamespace()); + final Set rpcs = new HashSet<>(); + final RpcDefinition rpcDefinition = mock(RpcDefinition.class); + final SchemaPath rpcPath = SchemaPath.create(true, rpcParentQName, rpcQName); + when(rpcDefinition.getPath()).thenReturn(rpcPath); + when(rpcDefinition.getQName()).thenReturn(rpcQName); + when(module.getDataChildByName(rpcParentQName)).thenReturn(rpcParent); + rpcs.add(rpcDefinition); + when(module.getRpcs()).thenReturn(rpcs); + + final ContainerSchemaNode input = mock(ContainerSchemaNode.class); + final QName qnameInput = QName.create(rpcQName, "rpc-input"); + final SchemaPath inputSchemaPath = SchemaPath.create(true, rpcQName, qnameInput); + when(input.getQName()).thenReturn(qnameInput); + when(input.getPath()).thenReturn(inputSchemaPath); + when(rpcDefinition.getInput()).thenReturn(input); + + final ContainerSchemaNode output = mock(ContainerSchemaNode.class); + final QName qnameOutput = QName.create(rpcQName, "rpc-output"); + final SchemaPath outputSchemaPath = SchemaPath.create(true, rpcQName, qnameOutput); + when(output.getQName()).thenReturn(qnameOutput); + when(output.getPath()).thenReturn(outputSchemaPath); + when(rpcDefinition.getOutput()).thenReturn(output); + + final Map genCtx = new HashMap<>(); + final ModuleContext moduleContext = new ModuleContext(); + genCtx.put(module, moduleContext); + + final SchemaContext schemaContext = mock(SchemaContext.class); + when(schemaContext.findModuleByNamespaceAndRevision(rpcQName.getNamespace(), rpcQName.getRevision())) + .thenReturn(module); + + final boolean verboseClassComments = false; + final Map> genTypeBuilders = new HashMap<>(); + final TypeProvider typeProvider = mock(TypeProvider.class); + + final Object[] args = { module, genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider }; + final Map result = + (Map) generate.invoke(RpcActionGenHelper.class, args); + assertNotNull(result); + } + + @SuppressWarnings({ "unchecked", "rawtypes" }) + private void actionMethodsToGenType(final Class clazz, + final boolean isRoutedRpc) throws Exception { + final Class[] parameterTypes = + { Module.class, Map.class, SchemaContext.class, boolean.class, Map.class, TypeProvider.class }; + Method generate; + if (isRoutedRpc) { + generate = RpcActionGenHelper.class.getDeclaredMethod("rpcMethodsToGenType", parameterTypes); + } else { + generate = RpcActionGenHelper.class.getDeclaredMethod("actionMethodsToGenType", parameterTypes); + } + assertNotNull(generate); + generate.setAccessible(true); + + final QName actionQName = QName.create("test.action", "2017-05-04", "action-test"); + + final Module module = mock(Module.class); + when(module.getName()).thenReturn("module-name"); + when(module.getRevision()).thenReturn(actionQName.getRevision()); + when(module.getNamespace()).thenReturn(actionQName.getNamespace()); + + final Collection childNodes = new ArrayList<>(); + final T actionNodeContainer = mock(clazz); + final QName actionParentQName = QName.create(actionQName, "action-parent"); + final SchemaPath actionParentPath = SchemaPath.create(true, actionParentQName); + when(((SchemaNode) actionNodeContainer).getPath()).thenReturn(actionParentPath); + when(((SchemaNode) actionNodeContainer).getQName()).thenReturn(actionParentQName); + if (clazz == ListSchemaNode.class) { + final List keyQNames = new ArrayList<>(); + keyQNames.add(QName.create(actionParentQName, "keyActions")); + when(((ListSchemaNode) actionNodeContainer).getKeyDefinition()).thenReturn(keyQNames); + } + + final Set actions = new HashSet<>(); + + final ActionDefinition actionDefinition = mock(ActionDefinition.class); + when(actionDefinition.getQName()).thenReturn(actionQName); + final SchemaPath actionPath = SchemaPath.create(true, actionQName); + when(actionDefinition.getPath()).thenReturn(actionPath); + + final ContainerSchemaNode input = mock(ContainerSchemaNode.class); + final QName qnameInput = QName.create(actionQName, "action-input"); + final SchemaPath inputSchemaPath = SchemaPath.create(true, actionQName, qnameInput); + when(input.getQName()).thenReturn(qnameInput); + when(input.getPath()).thenReturn(inputSchemaPath); + when(actionDefinition.getInput()).thenReturn(input); + + final ContainerSchemaNode output = mock(ContainerSchemaNode.class); + final QName qnameOutput = QName.create(actionQName, "action-output"); + final SchemaPath outputSchemaPath = SchemaPath.create(true, actionQName, qnameOutput); + when(output.getQName()).thenReturn(qnameOutput); + when(output.getPath()).thenReturn(outputSchemaPath); + when(actionDefinition.getOutput()).thenReturn(output); + + actions.add(actionDefinition); + when(actionNodeContainer.getActions()).thenReturn(actions); + childNodes.add((DataSchemaNode) actionNodeContainer); + when(module.getChildNodes()).thenReturn(childNodes); + + final Map genCtx = new HashMap<>(); + final ModuleContext moduleContext = new ModuleContext(); + genCtx.put(module, moduleContext); + + final SchemaContext schemaContext = mock(SchemaContext.class); + when(schemaContext.findModuleByNamespaceAndRevision(actionQName.getNamespace(), actionQName.getRevision())) + .thenReturn(module); + + final boolean verboseClassComments = false; + final Map> genTypeBuilders = new HashMap<>(); + final TypeProvider typeProvider = mock(TypeProvider.class); + + if (isRoutedRpc) { + final Set rpcs = new HashSet<>(); + final RpcDefinition rpcDef = mock(RpcDefinition.class); + when(rpcDef.getPath()).thenReturn(outputSchemaPath); + when(rpcDef.getQName()).thenReturn(qnameOutput); + when(module.getDataChildByName(actionQName)).thenReturn((ContainerSchemaNode) actionNodeContainer); + final List unknownSchemaNodes = new ArrayList<>(); + final UnknownSchemaNode unknownSchemaNode = mock(UnknownSchemaNode.class); + final Field contextRef = RpcActionGenHelper.class.getDeclaredField("CONTEXT_REFERENCE"); + contextRef.setAccessible(true); + final QName nodeType = (QName) contextRef.get(RpcActionGenHelper.class); + when(unknownSchemaNode.getNodeType()).thenReturn(nodeType); + when(unknownSchemaNode.getQName()).thenReturn(nodeType); + unknownSchemaNodes.add(unknownSchemaNode); + when(((DataSchemaNode) actionNodeContainer).getUnknownSchemaNodes()).thenReturn(unknownSchemaNodes); + when(rpcDef.getInput()).thenReturn(input); + when(rpcDef.getOutput()).thenReturn(output); + rpcs.add(rpcDef); + when(module.getRpcs()).thenReturn(rpcs); + } + + final Object[] args = { module, genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider }; + final Map result = + (Map) generate.invoke(RpcActionGenHelper.class, args); + assertNotNull(result); + } +}