binding2/mdsal-binding2-generator-impl/src/test/java/org/opendaylight/mdsal/binding/javav2/generator/impl/RpcActionGenHelperTest.java

   1 /*
   2  * Copyright (c) 2017 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.mdsal.binding.javav2.generator.impl;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertNotNull;
  12 import static org.junit.Assert.assertTrue;
  13 import static org.mockito.Mockito.mock;
  14 import static org.mockito.Mockito.when;
  15
  16 import java.lang.reflect.Constructor;
  17 import java.util.ArrayList;
  18 import java.util.Collection;
  19 import java.util.HashMap;
  20 import java.util.HashSet;
  21 import java.util.List;
  22 import java.util.Map;
  23 import java.util.Optional;
  24 import java.util.Set;
  25 import org.junit.Ignore;
  26 import org.junit.Test;
  27 import org.opendaylight.mdsal.binding.javav2.generator.context.ModuleContext;
  28 import org.opendaylight.mdsal.binding.javav2.generator.spi.TypeProvider;
  29 import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTypeBuilder;
  30 import org.opendaylight.yangtools.yang.common.QName;
  31 import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
  32 import org.opendaylight.yangtools.yang.model.api.ActionNodeContainer;
  33 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
  34 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  35 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
  36 import org.opendaylight.yangtools.yang.model.api.Module;
  37 import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
  38 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  39 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
  40 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  41 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
  42
  43 public class RpcActionGenHelperTest {
  44     // Bridge for method references
  45     @FunctionalInterface
  46     private static interface GeneratorMethod {
  47         Map<Module, ModuleContext> generate(Module module, Map<Module, ModuleContext> genCtx,
  48                 SchemaContext schemaContext, boolean verboseClassComments,
  49                 Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, TypeProvider typeProvider);
  50     }
  51
  52     @Test(expected = UnsupportedOperationException.class)
  53     public void constructorTest() throws Throwable {
  54         final Constructor<RpcActionGenHelper> constructor = RpcActionGenHelper.class.getDeclaredConstructor();
  55         constructor.setAccessible(true);
  56         try {
  57             constructor.newInstance();
  58         } catch (final Exception e) {
  59             throw e.getCause();
  60         }
  61     }
  62
  63     @Test
  64     public void getRoutingContextAbsentTest() {
  65         final DataSchemaNode dataSchemaNode = mock(DataSchemaNode.class);
  66         final List<UnknownSchemaNode> unknownSchemaNodes = new ArrayList<>();
  67         when(dataSchemaNode.getUnknownSchemaNodes()).thenReturn(unknownSchemaNodes);
  68
  69         final Optional<QName> result = RpcActionGenHelper.getRoutingContext(dataSchemaNode);
  70         assertNotNull(result);
  71         assertTrue(!result.isPresent());
  72     }
  73
  74     @Test
  75     public void getRoutingContextTest() {
  76         final DataSchemaNode dataSchemaNode = mock(DataSchemaNode.class);
  77         final List<UnknownSchemaNode> unknownSchemaNodes = new ArrayList<>();
  78         final UnknownSchemaNode unknownSchemaNode = mock(UnknownSchemaNode.class);
  79         when(unknownSchemaNode.getNodeType()).thenReturn(RpcActionGenHelper.CONTEXT_REFERENCE);
  80         final QName qname = QName.create("test", "2017-05-04", "unknown");
  81         when(unknownSchemaNode.getQName()).thenReturn(qname);
  82         unknownSchemaNodes.add(unknownSchemaNode);
  83         when(dataSchemaNode.getUnknownSchemaNodes()).thenReturn(unknownSchemaNodes);
  84
  85         final Optional<QName> result = RpcActionGenHelper.getRoutingContext(dataSchemaNode);
  86         assertNotNull(result);
  87         assertTrue(result.isPresent());
  88         assertEquals(qname, result.get());
  89     }
  90
  91     @Ignore
  92     @Test
  93     public void actionMethodsToGenTypeContainerAsParentTest() {
  94         actionMethodsToGenType(ContainerSchemaNode.class, false);
  95     }
  96
  97     @Ignore
  98     @Test
  99     public void actionMethodsToGenTypeListAsParentTest() {
 100         actionMethodsToGenType(ListSchemaNode.class, false);
 101     }
 102
 103     @Test(expected = IllegalStateException.class)
 104     public void rpcMethodsToGenTypeNullRpcsTest() {
 105         final QName rpcQName = QName.create("test.rpc", "2017-05-04", "rpc-test");
 106
 107         final Module module = mock(Module.class);
 108         when(module.getName()).thenReturn("module-name");
 109         when(module.getRevision()).thenReturn(rpcQName.getRevision());
 110         when(module.getNamespace()).thenReturn(rpcQName.getNamespace());
 111         when(module.getRpcs()).thenReturn(null);
 112
 113         final Map<Module, ModuleContext> genCtx = new HashMap<>();
 114         final SchemaContext schemaContext = mock(SchemaContext.class);
 115         final boolean verboseClassComments = false;
 116         final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders = new HashMap<>();
 117         final TypeProvider typeProvider = mock(TypeProvider.class);
 118
 119         RpcActionGenHelper.rpcMethodsToGenType(module, genCtx, schemaContext, verboseClassComments, genTypeBuilders,
 120             typeProvider);
 121     }
 122
 123     @Test
 124     public void rpcMethodsToGenTypeEmptyRpcsTest() {
 125         final QName rpcQName = QName.create("test.rpc", "2017-05-04", "rpc-test");
 126
 127         final Module module = mock(Module.class);
 128         when(module.getName()).thenReturn("module-name");
 129         when(module.getRevision()).thenReturn(rpcQName.getRevision());
 130         when(module.getNamespace()).thenReturn(rpcQName.getNamespace());
 131         final Set<RpcDefinition> rpcs = new HashSet<>();
 132         when(module.getRpcs()).thenReturn(rpcs);
 133
 134         final Map<Module, ModuleContext> genCtx = new HashMap<>();
 135         final SchemaContext schemaContext = mock(SchemaContext.class);
 136         final boolean verboseClassComments = false;
 137         final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders = new HashMap<>();
 138         final TypeProvider typeProvider = mock(TypeProvider.class);
 139
 140         final Map<Module, ModuleContext> result = RpcActionGenHelper.rpcMethodsToGenType(module, genCtx, schemaContext,
 141             verboseClassComments, genTypeBuilders, typeProvider);
 142         assertNotNull(result);
 143     }
 144
 145     @Test
 146     public void rpcMethodsToGenTypeRoutedRpcTest() {
 147         actionMethodsToGenType(ContainerSchemaNode.class, true);
 148     }
 149
 150     @Test
 151     public void rpcMethodsToGenTypeRpcTest() {
 152         final QName rpcQName = QName.create("test.rpc", "2017-05-04", "rpc-test");
 153
 154         final ContainerSchemaNode rpcParent = mock(ContainerSchemaNode.class);
 155         final QName rpcParentQName = QName.create(rpcQName, "rpc-parent");
 156         when(rpcParent.getQName()).thenReturn(rpcParentQName);
 157
 158         final Module module = mock(Module.class);
 159         when(module.getName()).thenReturn("module-name");
 160         when(module.getRevision()).thenReturn(rpcQName.getRevision());
 161         when(module.getNamespace()).thenReturn(rpcQName.getNamespace());
 162         when(module.getDescription()).thenReturn(java.util.Optional.empty());
 163         when(module.getReference()).thenReturn(java.util.Optional.empty());
 164         final Set<RpcDefinition> rpcs = new HashSet<>();
 165         final RpcDefinition rpcDefinition = mock(RpcDefinition.class);
 166         when(rpcDefinition.getDescription()).thenReturn(java.util.Optional.empty());
 167         when(rpcDefinition.getReference()).thenReturn(java.util.Optional.empty());
 168         final SchemaPath rpcPath = SchemaPath.create(true, rpcParentQName, rpcQName);
 169         when(rpcDefinition.getPath()).thenReturn(rpcPath);
 170         when(rpcDefinition.getQName()).thenReturn(rpcQName);
 171
 172         when(module.getDataChildByName(rpcParentQName)).thenReturn(rpcParent);
 173         rpcs.add(rpcDefinition);
 174         when(module.getRpcs()).thenReturn(rpcs);
 175
 176         final ContainerSchemaNode input = mock(ContainerSchemaNode.class);
 177         final QName qnameInput = QName.create(rpcQName, "rpc-input");
 178         final SchemaPath inputSchemaPath = SchemaPath.create(true, rpcQName, qnameInput);
 179         when(input.getQName()).thenReturn(qnameInput);
 180         when(input.getPath()).thenReturn(inputSchemaPath);
 181         when(input.getDescription()).thenReturn(java.util.Optional.empty());
 182         when(input.getReference()).thenReturn(java.util.Optional.empty());
 183
 184         when(rpcDefinition.getInput()).thenReturn(input);
 185
 186         final ContainerSchemaNode output = mock(ContainerSchemaNode.class);
 187         final QName qnameOutput = QName.create(rpcQName, "rpc-output");
 188         final SchemaPath outputSchemaPath = SchemaPath.create(true, rpcQName, qnameOutput);
 189         when(output.getQName()).thenReturn(qnameOutput);
 190         when(output.getPath()).thenReturn(outputSchemaPath);
 191         when(output.getDescription()).thenReturn(java.util.Optional.empty());
 192         when(output.getReference()).thenReturn(java.util.Optional.empty());
 193         when(rpcDefinition.getOutput()).thenReturn(output);
 194
 195         final Map<Module, ModuleContext> genCtx = new HashMap<>();
 196         final ModuleContext moduleContext = new ModuleContext();
 197         genCtx.put(module, moduleContext);
 198
 199         final SchemaContext schemaContext = mock(SchemaContext.class);
 200         when(schemaContext.findModule(rpcQName.getModule())).thenReturn(java.util.Optional.of(module));
 201
 202         final boolean verboseClassComments = false;
 203         final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders = new HashMap<>();
 204         final TypeProvider typeProvider = mock(TypeProvider.class);
 205
 206         final Map<Module, ModuleContext> result = RpcActionGenHelper.rpcMethodsToGenType(module, genCtx, schemaContext,
 207             verboseClassComments, genTypeBuilders, typeProvider);
 208         assertNotNull(result);
 209     }
 210
 211     private static <T extends ActionNodeContainer> void actionMethodsToGenType(final Class<T> clazz,
 212             final boolean isRoutedRpc) {
 213         final GeneratorMethod generate;
 214         if (isRoutedRpc) {
 215             generate = RpcActionGenHelper::rpcMethodsToGenType;
 216         } else {
 217             generate = RpcActionGenHelper::actionMethodsToGenType;
 218         }
 219
 220         final QName actionQName = QName.create("test.action", "2017-05-04", "action-test");
 221
 222         final Module module = mock(Module.class);
 223         when(module.getName()).thenReturn("module-name");
 224         when(module.getRevision()).thenReturn(actionQName.getRevision());
 225         when(module.getNamespace()).thenReturn(actionQName.getNamespace());
 226         when(module.getDescription()).thenReturn(java.util.Optional.empty());
 227         when(module.getReference()).thenReturn(java.util.Optional.empty());
 228
 229         final Collection<DataSchemaNode> childNodes = new ArrayList<>();
 230         final T actionNodeContainer = mock(clazz);
 231         final QName actionParentQName = QName.create(actionQName, "action-parent");
 232         final SchemaPath actionParentPath = SchemaPath.create(true, actionParentQName);
 233         when(((SchemaNode) actionNodeContainer).getPath()).thenReturn(actionParentPath);
 234         when(((SchemaNode) actionNodeContainer).getQName()).thenReturn(actionParentQName);
 235         if (clazz == ListSchemaNode.class) {
 236             final List<QName> keyQNames = new ArrayList<>();
 237             keyQNames.add(QName.create(actionParentQName, "keyActions"));
 238             when(((ListSchemaNode) actionNodeContainer).getKeyDefinition()).thenReturn(keyQNames);
 239         }
 240
 241         final Set<ActionDefinition> actions = new HashSet<>();
 242
 243         final ActionDefinition actionDefinition = mock(ActionDefinition.class);
 244         when(actionDefinition.getQName()).thenReturn(actionQName);
 245         final SchemaPath actionPath = SchemaPath.create(true, actionQName);
 246         when(actionDefinition.getPath()).thenReturn(actionPath);
 247         when(actionDefinition.getDescription()).thenReturn(java.util.Optional.empty());
 248         when(actionDefinition.getReference()).thenReturn(java.util.Optional.empty());
 249
 250         final ContainerSchemaNode input = mock(ContainerSchemaNode.class);
 251         final QName qnameInput = QName.create(actionQName, "action-input");
 252         final SchemaPath inputSchemaPath = SchemaPath.create(true, actionQName, qnameInput);
 253         when(input.getQName()).thenReturn(qnameInput);
 254         when(input.getPath()).thenReturn(inputSchemaPath);
 255         when(input.getDescription()).thenReturn(java.util.Optional.empty());
 256         when(input.getReference()).thenReturn(java.util.Optional.empty());
 257         when(actionDefinition.getInput()).thenReturn(input);
 258
 259         final ContainerSchemaNode output = mock(ContainerSchemaNode.class);
 260         final QName qnameOutput = QName.create(actionQName, "action-output");
 261         final SchemaPath outputSchemaPath = SchemaPath.create(true, actionQName, qnameOutput);
 262         when(output.getQName()).thenReturn(qnameOutput);
 263         when(output.getPath()).thenReturn(outputSchemaPath);
 264         when(output.getDescription()).thenReturn(java.util.Optional.empty());
 265         when(output.getReference()).thenReturn(java.util.Optional.empty());
 266         when(actionDefinition.getOutput()).thenReturn(output);
 267
 268         actions.add(actionDefinition);
 269         when(actionNodeContainer.getActions()).thenReturn(actions);
 270         childNodes.add((DataSchemaNode) actionNodeContainer);
 271         when(module.getChildNodes()).thenReturn(childNodes);
 272
 273         final Map<Module, ModuleContext> genCtx = new HashMap<>();
 274         final ModuleContext moduleContext = new ModuleContext();
 275         genCtx.put(module, moduleContext);
 276
 277         final SchemaContext schemaContext = mock(SchemaContext.class);
 278         when(schemaContext.findModule(actionQName.getModule())).thenReturn(java.util.Optional.of(module));
 279
 280         final boolean verboseClassComments = false;
 281         final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders = new HashMap<>();
 282         final TypeProvider typeProvider = mock(TypeProvider.class);
 283
 284         if (isRoutedRpc) {
 285             final Set<RpcDefinition> rpcs = new HashSet<>();
 286             final RpcDefinition rpcDef = mock(RpcDefinition.class);
 287             when(rpcDef.getPath()).thenReturn(outputSchemaPath);
 288             when(rpcDef.getQName()).thenReturn(qnameOutput);
 289             when(rpcDef.getDescription()).thenReturn(java.util.Optional.empty());
 290             when(rpcDef.getReference()).thenReturn(java.util.Optional.empty());
 291
 292             when(module.getDataChildByName(actionQName)).thenReturn((ContainerSchemaNode) actionNodeContainer);
 293             final List<UnknownSchemaNode> unknownSchemaNodes = new ArrayList<>();
 294             final UnknownSchemaNode unknownSchemaNode = mock(UnknownSchemaNode.class);
 295             when(unknownSchemaNode.getNodeType()).thenReturn(RpcActionGenHelper.CONTEXT_REFERENCE);
 296             when(unknownSchemaNode.getQName()).thenReturn(RpcActionGenHelper.CONTEXT_REFERENCE);
 297             unknownSchemaNodes.add(unknownSchemaNode);
 298             when(((DataSchemaNode) actionNodeContainer).getUnknownSchemaNodes()).thenReturn(unknownSchemaNodes);
 299             when(rpcDef.getInput()).thenReturn(input);
 300             when(rpcDef.getOutput()).thenReturn(output);
 301             rpcs.add(rpcDef);
 302             when(module.getRpcs()).thenReturn(rpcs);
 303         }
 304
 305         final Map<Module, ModuleContext> result = generate.generate(module, genCtx, schemaContext, verboseClassComments,
 306             genTypeBuilders, typeProvider);
 307         assertNotNull(result);
 308     }
 309 }