2 * Copyright (c) 2017 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.mdsal.binding.javav2.generator.impl;
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;
16 import com.google.common.base.Optional;
17 import java.lang.reflect.Constructor;
18 import java.util.ArrayList;
19 import java.util.Collection;
20 import java.util.HashMap;
21 import java.util.HashSet;
22 import java.util.List;
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;
43 public class RpcActionGenHelperTest {
44 // Bridge for method references
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);
52 @Test(expected = UnsupportedOperationException.class)
53 public void constructorTest() throws Throwable {
54 final Constructor<RpcActionGenHelper> constructor = RpcActionGenHelper.class.getDeclaredConstructor();
55 constructor.setAccessible(true);
57 constructor.newInstance();
58 } catch (final Exception e) {
64 public void getRoutingContextAbsentTest() {
65 final DataSchemaNode dataSchemaNode = mock(DataSchemaNode.class);
66 final List<UnknownSchemaNode> unknownSchemaNodes = new ArrayList<>();
67 when(dataSchemaNode.getUnknownSchemaNodes()).thenReturn(unknownSchemaNodes);
69 final Optional<QName> result = RpcActionGenHelper.getRoutingContext(dataSchemaNode);
70 assertNotNull(result);
71 assertTrue(!result.isPresent());
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);
85 final Optional<QName> result = RpcActionGenHelper.getRoutingContext(dataSchemaNode);
86 assertNotNull(result);
87 assertTrue(result.isPresent());
88 assertEquals(qname, result.get());
93 public void actionMethodsToGenTypeContainerAsParentTest() {
94 actionMethodsToGenType(ContainerSchemaNode.class, false);
99 public void actionMethodsToGenTypeListAsParentTest() {
100 actionMethodsToGenType(ListSchemaNode.class, false);
103 @Test(expected = IllegalStateException.class)
104 public void rpcMethodsToGenTypeNullRpcsTest() {
105 final QName rpcQName = QName.create("test.rpc", "2017-05-04", "rpc-test");
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);
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);
119 RpcActionGenHelper.rpcMethodsToGenType(module, genCtx, schemaContext, verboseClassComments, genTypeBuilders,
124 public void rpcMethodsToGenTypeEmptyRpcsTest() {
125 final QName rpcQName = QName.create("test.rpc", "2017-05-04", "rpc-test");
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);
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);
140 final Map<Module, ModuleContext> result = RpcActionGenHelper.rpcMethodsToGenType(module, genCtx, schemaContext,
141 verboseClassComments, genTypeBuilders, typeProvider);
142 assertNotNull(result);
146 public void rpcMethodsToGenTypeRoutedRpcTest() {
147 actionMethodsToGenType(ContainerSchemaNode.class, true);
151 public void rpcMethodsToGenTypeRpcTest() {
152 final QName rpcQName = QName.create("test.rpc", "2017-05-04", "rpc-test");
154 final ContainerSchemaNode rpcParent = mock(ContainerSchemaNode.class);
155 final QName rpcParentQName = QName.create(rpcQName, "rpc-parent");
156 when(rpcParent.getQName()).thenReturn(rpcParentQName);
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);
172 when(module.getDataChildByName(rpcParentQName)).thenReturn(rpcParent);
173 rpcs.add(rpcDefinition);
174 when(module.getRpcs()).thenReturn(rpcs);
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());
184 when(rpcDefinition.getInput()).thenReturn(input);
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);
195 final Map<Module, ModuleContext> genCtx = new HashMap<>();
196 final ModuleContext moduleContext = new ModuleContext();
197 genCtx.put(module, moduleContext);
199 final SchemaContext schemaContext = mock(SchemaContext.class);
200 when(schemaContext.findModule(rpcQName.getModule())).thenReturn(java.util.Optional.of(module));
202 final boolean verboseClassComments = false;
203 final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders = new HashMap<>();
204 final TypeProvider typeProvider = mock(TypeProvider.class);
206 final Map<Module, ModuleContext> result = RpcActionGenHelper.rpcMethodsToGenType(module, genCtx, schemaContext,
207 verboseClassComments, genTypeBuilders, typeProvider);
208 assertNotNull(result);
211 private static <T extends ActionNodeContainer> void actionMethodsToGenType(final Class<T> clazz,
212 final boolean isRoutedRpc) {
213 final GeneratorMethod generate;
215 generate = RpcActionGenHelper::rpcMethodsToGenType;
217 generate = RpcActionGenHelper::actionMethodsToGenType;
220 final QName actionQName = QName.create("test.action", "2017-05-04", "action-test");
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());
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);
241 final Set<ActionDefinition> actions = new HashSet<>();
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());
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);
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);
268 actions.add(actionDefinition);
269 when(actionNodeContainer.getActions()).thenReturn(actions);
270 childNodes.add((DataSchemaNode) actionNodeContainer);
271 when(module.getChildNodes()).thenReturn(childNodes);
273 final Map<Module, ModuleContext> genCtx = new HashMap<>();
274 final ModuleContext moduleContext = new ModuleContext();
275 genCtx.put(module, moduleContext);
277 final SchemaContext schemaContext = mock(SchemaContext.class);
278 when(schemaContext.findModule(actionQName.getModule())).thenReturn(java.util.Optional.of(module));
280 final boolean verboseClassComments = false;
281 final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders = new HashMap<>();
282 final TypeProvider typeProvider = mock(TypeProvider.class);
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());
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);
302 when(module.getRpcs()).thenReturn(rpcs);
305 final Map<Module, ModuleContext> result = generate.generate(module, genCtx, schemaContext, verboseClassComments,
306 genTypeBuilders, typeProvider);
307 assertNotNull(result);