8ca2bb5bc98247198a405fe8cb75bd42561f642e
[controller.git] / opendaylight / config / yang-jmx-generator / src / test / java / org / opendaylight / controller / config / yangjmxgenerator / ModuleMXBeanEntryTest.java
1 /*
2  * Copyright (c) 2013 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.controller.config.yangjmxgenerator;
9
10 import com.google.common.collect.Sets;
11 import java.util.HashMap;
12 import org.junit.Before;
13 import org.junit.Test;
14 import org.opendaylight.controller.config.yangjmxgenerator.attribute.AttributeIfc;
15 import org.opendaylight.controller.config.yangjmxgenerator.attribute.DependencyAttribute;
16 import org.opendaylight.controller.config.yangjmxgenerator.attribute.JavaAttribute;
17 import org.opendaylight.controller.config.yangjmxgenerator.attribute.ListAttribute;
18 import org.opendaylight.controller.config.yangjmxgenerator.attribute.ListDependenciesAttribute;
19 import org.opendaylight.controller.config.yangjmxgenerator.attribute.TOAttribute;
20 import org.opendaylight.controller.config.yangjmxgenerator.attribute.TypedAttribute;
21 import org.opendaylight.yangtools.binding.generator.util.Types;
22 import org.opendaylight.yangtools.sal.binding.model.api.Type;
23 import org.opendaylight.yangtools.sal.binding.yang.types.TypeProviderImpl;
24 import org.opendaylight.yangtools.yang.common.QName;
25 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
26 import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
27 import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
28
29 import javax.management.openmbean.ArrayType;
30 import javax.management.openmbean.CompositeType;
31 import javax.management.openmbean.SimpleType;
32 import java.net.URI;
33 import java.net.URISyntaxException;
34 import java.text.ParseException;
35 import java.text.SimpleDateFormat;
36 import java.util.Collection;
37 import java.util.Collections;
38 import java.util.Date;
39 import java.util.HashSet;
40 import java.util.Map;
41 import java.util.Set;
42 import java.util.regex.Matcher;
43
44 import static org.hamcrest.CoreMatchers.is;
45 import static org.junit.Assert.assertEquals;
46 import static org.junit.Assert.assertFalse;
47 import static org.junit.Assert.assertNotNull;
48 import static org.junit.Assert.assertNull;
49 import static org.junit.Assert.assertThat;
50 import static org.junit.Assert.assertTrue;
51 import static org.mockito.Mockito.doReturn;
52 import static org.mockito.Mockito.mock;
53
54 public class ModuleMXBeanEntryTest extends AbstractYangTest {
55     public static final String EVENTBUS_MXB_NAME = "eventbus";
56     public static final String ASYNC_EVENTBUS_MXB_NAME = "async-eventbus";
57     public static final String THREADFACTORY_NAMING_MXB_NAME = "threadfactory-naming";
58     public static final String THREADPOOL_DYNAMIC_MXB_NAME = "threadpool-dynamic";
59     public static final String THREADPOOL_REGISTRY_IMPL_NAME = "threadpool-registry-impl";
60
61     public static final String BGP_LISTENER_IMPL_MXB_NAME = "bgp-listener-impl";
62
63     public static final String PACKAGE_NAME = "pack2";
64
65     protected static final URI THREADS_NAMESPACE;
66     protected static final Date THREADS_REVISION_DATE;
67
68     static {
69         try {
70             THREADS_NAMESPACE = new URI(ConfigConstants.CONFIG_NAMESPACE
71                     + ":threads");
72         } catch (URISyntaxException e) {
73             throw new Error(e);
74         }
75         SimpleDateFormat revisionFormat = new SimpleDateFormat("yyyy-MM-dd");
76         try {
77             THREADS_REVISION_DATE = revisionFormat.parse("2013-04-09");
78         } catch (ParseException e) {
79             throw new Error(e);
80         }
81     }
82
83     protected Map<QName, ServiceInterfaceEntry> modulesToSIEs;
84
85     protected Map<String /* identity local name */, ModuleMXBeanEntry> loadThreadsJava() {
86         Map<String /* identity local name */, ModuleMXBeanEntry> namesToMBEs = ModuleMXBeanEntry
87                 .create(threadsJavaModule, modulesToSIEs, context, new TypeProviderWrapper(new TypeProviderImpl
88                         (context)), PACKAGE_NAME);
89         assertNotNull(namesToMBEs);
90         Set<String> expectedMXBeanNames = Sets.newHashSet(EVENTBUS_MXB_NAME,
91                 ASYNC_EVENTBUS_MXB_NAME, THREADFACTORY_NAMING_MXB_NAME,
92                 THREADPOOL_DYNAMIC_MXB_NAME, THREADPOOL_REGISTRY_IMPL_NAME);
93         assertThat(namesToMBEs.keySet(), is(expectedMXBeanNames));
94         return namesToMBEs;
95     }
96
97     @Before
98     public void setUp() {
99         Map<IdentitySchemaNode, ServiceInterfaceEntry> identitiesToSIs = new HashMap<>();
100         modulesToSIEs = ServiceInterfaceEntry.create(threadsModule,
101                 "packages.sis",identitiesToSIs);
102     }
103
104     @Test
105     public void test_jmxImplModule() {
106         Map<IdentitySchemaNode, ServiceInterfaceEntry> identitiesToSIs = new HashMap<>();
107         Map<QName, ServiceInterfaceEntry> modulesToSIEs = ServiceInterfaceEntry
108                 .create(threadsModule, PACKAGE_NAME,identitiesToSIs);
109         modulesToSIEs.putAll(ServiceInterfaceEntry.create(jmxModule,
110                 PACKAGE_NAME,identitiesToSIs));
111         Map<String /* identity local name */, ModuleMXBeanEntry> namesToMBEs = ModuleMXBeanEntry
112                 .create(jmxImplModule, modulesToSIEs, context, new TypeProviderWrapper(new TypeProviderImpl(context))
113                         , PACKAGE_NAME);
114         Map<String, AttributeIfc> attributes = namesToMBEs.get("impl-netconf")
115                 .getAttributes();
116
117         assertCorrectAttributesSize(namesToMBEs, attributes);
118
119         //
120         DependencyAttribute threadFactoryAttribute = (DependencyAttribute) attributes
121                 .get("thread-factory");
122         assertNotNull(threadFactoryAttribute);
123         assertFalse(threadFactoryAttribute.getDependency().isMandatory());
124         assertThat(threadFactoryAttribute.getDependency().getSie()
125                 .getTypeName(), is("ThreadFactoryServiceInterface"));
126         assertThat(threadFactoryAttribute.getAttributeYangName(),
127                 is("thread-factory"));
128         assertThat(threadFactoryAttribute.getLowerCaseCammelCase(),
129                 is("threadFactory"));
130         assertThat(threadFactoryAttribute.getUpperCaseCammelCase(),
131                 is("ThreadFactory"));
132         assertThat(threadFactoryAttribute.getOpenType(), is(SimpleType.class));
133         assertNull(threadFactoryAttribute.getNullableDefault());
134         assertNull(threadFactoryAttribute.getNullableDescription());
135         assertThat(threadFactoryAttribute.getType().getName(), is("ObjectName"));
136     }
137
138     private void assertCorrectAttributesSize(Map<String, ModuleMXBeanEntry> namesToMBEs, Map<String, AttributeIfc> attributes) {
139         assertEquals(14, attributes.size());
140         assertEquals(1, namesToMBEs.get("impl-netconf").getRuntimeBeans().size());
141         assertEquals(2, namesToMBEs.get("impl-netconf").getRuntimeBeans().iterator().next().getAttributes().size());
142
143         assertEquals(4, namesToMBEs.get("impl").getAttributes().size());
144         assertEquals(1, namesToMBEs.get("impl").getRuntimeBeans().size());
145         assertEquals(1, namesToMBEs.get("impl").getRuntimeBeans().iterator().next().getAttributes().size());
146     }
147
148     protected RuntimeBeanEntry findFirstByYangName(
149             Collection<RuntimeBeanEntry> runtimeBeans, String yangName) {
150         for (RuntimeBeanEntry rb : runtimeBeans) {
151             if (yangName.equals(rb.getYangName()))
152                 return rb;
153         }
154         throw new IllegalArgumentException("Yang name not found:" + yangName
155                 + " in " + runtimeBeans);
156     }
157
158     @Test
159     public void testGetWhenConditionMatcher() {
160         assertMatches("config",
161                 "/config:modules/config:module/config:type = 'threadpool-dynamic'");
162         assertMatches("ns",
163                 "/ns:modules/ns:module/ns:type = 'threadpool-dynamic'");
164         assertMatches("config",
165                 "/config:modules/config:module/config:type=\"threadpool-dynamic\"");
166     }
167
168     private void assertMatches(String prefix, String input) {
169         RevisionAwareXPath whenConstraint = mock(RevisionAwareXPath.class);
170         doReturn(input).when(whenConstraint).toString();
171         Matcher output = ModuleMXBeanEntryBuilder.getWhenConditionMatcher(prefix,
172                 whenConstraint);
173         assertTrue(output.matches());
174         assertEquals("threadpool-dynamic", output.group(1));
175     }
176
177     @Test
178     public void testThreadsJava() {
179         Map<String /* identity local name */, ModuleMXBeanEntry> namesToMBEs = loadThreadsJava();
180
181         { // check threadpool-dynamic
182             ModuleMXBeanEntry dynamicThreadPool = namesToMBEs
183                     .get(THREADPOOL_DYNAMIC_MXB_NAME);
184             Map<String, AttributeIfc> attributes = dynamicThreadPool
185                     .getAttributes();
186             // core-size, keepalive, maximum-size
187             // threadfactory
188             Set<String> longAttribs = Sets.newHashSet("core-size",
189                     "maximum-size");
190             for (String longAttrib : longAttribs) {
191
192                 TypedAttribute attribute = (TypedAttribute) attributes
193                         .get(longAttrib);
194                 assertThat("Failed to check " + longAttrib,
195                         attribute.getType(),
196                         is((Type) Types.typeForClass(Long.class)));
197             }
198             // check dependency on thread factory
199             QName threadfactoryQName = new QName(THREADS_NAMESPACE,
200                     THREADS_REVISION_DATE, "threadfactory");
201             ServiceInterfaceEntry threadFactorySIEntry = modulesToSIEs
202                     .get(threadfactoryQName);
203             assertNotNull(threadFactorySIEntry);
204             boolean expectedMandatory = true;
205             TypedAttribute actualThreadFactory = (TypedAttribute) attributes
206                     .get("threadfactory");
207
208             DataSchemaNode mockedDataSchemaNode = mock(DataSchemaNode.class);
209             doReturn(Collections.emptyList()).when(mockedDataSchemaNode)
210                     .getUnknownSchemaNodes();
211             doReturn(threadfactoryQName).when(mockedDataSchemaNode).getQName();
212             AttributeIfc expectedDependencyAttribute = new DependencyAttribute(
213                     mockedDataSchemaNode, threadFactorySIEntry,
214                     expectedMandatory, "threadfactory description");
215             assertThat(actualThreadFactory, is(expectedDependencyAttribute));
216             assertThat(
217                     dynamicThreadPool
218                             .getFullyQualifiedName("DynamicThreadPoolModuleMXBean"),
219                     is(PACKAGE_NAME + ".DynamicThreadPoolModuleMXBean"));
220             assertThat(dynamicThreadPool.getNullableDescription(),
221                     is("threadpool-dynamic description"));
222             assertThat(dynamicThreadPool.getYangModuleName(),
223                     is("config-threads-java"));
224             assertThat(dynamicThreadPool.getYangModuleLocalname(),
225                     is(THREADPOOL_DYNAMIC_MXB_NAME));
226
227             // check root runtime bean
228             Collection<RuntimeBeanEntry> runtimeBeans = dynamicThreadPool
229                     .getRuntimeBeans();
230             assertThat(runtimeBeans.size(), is(1));
231             RuntimeBeanEntry rootRB = findFirstByYangName(runtimeBeans,
232                     THREADPOOL_DYNAMIC_MXB_NAME);
233             assertThat(rootRB.isRoot(), is(true));
234             assertThat(rootRB.getAttributes().size(), is(1));
235             JavaAttribute attribute = (JavaAttribute) rootRB.getAttributes()
236                     .iterator().next();
237             assertThat(attribute.getAttributeYangName(), is("created-sessions"));
238             assertThat(rootRB.getYangName(), is(THREADPOOL_DYNAMIC_MXB_NAME));
239             assertThat(attribute.getType().getFullyQualifiedName(),
240                     is(Long.class.getName()));
241         }
242         {// check threadfactory-naming
243             ModuleMXBeanEntry threadFactoryNaming = namesToMBEs
244                     .get(THREADFACTORY_NAMING_MXB_NAME);
245             Collection<RuntimeBeanEntry> runtimeBeans = threadFactoryNaming
246                     .getRuntimeBeans();
247             assertThat(runtimeBeans.size(), is(4));
248             {
249                 RuntimeBeanEntry threadRB = findFirstByYangName(runtimeBeans,
250                         "thread");
251                 assertNotNull(threadRB);
252                 assertFalse(threadRB.isRoot());
253                 assertEquals("name", threadRB.getKeyYangName().get());
254                 assertEquals("Name", threadRB.getKeyJavaName().get());
255                 assertThat(threadRB.getAttributes().size(), is(1));
256                 AttributeIfc threadNameAttr = threadRB.getAttributes()
257                         .iterator().next();
258                 assertThat(threadNameAttr.getAttributeYangName(), is("name"));
259                 assertTrue(threadNameAttr instanceof JavaAttribute);
260                 assertThat(((JavaAttribute) threadNameAttr).getType()
261                         .getFullyQualifiedName(), is(String.class.getName()));
262                 assertThat(threadRB.getRpcs().size(), is(2));
263             }
264             {
265                 RuntimeBeanEntry streamRB = findFirstByYangName(runtimeBeans,
266                         "stream");
267                 assertNotNull(streamRB);
268                 assertFalse(streamRB.getKeyYangName().isPresent());
269                 assertFalse(streamRB.getKeyJavaName().isPresent());
270                 Map<String, AttributeIfc> attributeMap = streamRB
271                         .getYangPropertiesToTypesMap();
272                 assertEquals(4, attributeMap.size());
273
274                 TOAttribute toAttr = (TOAttribute) attributeMap.get("peer");
275                 assertNotNull(toAttr);
276                 assertThat(toAttr.getAttributeYangName(), is("peer"));
277                 assertThat(toAttr.getLowerCaseCammelCase(), is("peer"));
278                 assertThat(toAttr.getUpperCaseCammelCase(), is("Peer"));
279                 assertThat(toAttr.getOpenType(), is(CompositeType.class));
280                 Set<String> propsExpected = new HashSet<String>(2);
281                 propsExpected.add("port");
282                 propsExpected.add("core-size");
283                 assertThat(toAttr.getYangPropertiesToTypesMap().keySet(),
284                         is(propsExpected));
285                 propsExpected = new HashSet<String>(2);
286                 propsExpected.add("Port");
287                 propsExpected.add("CoreSize");
288                 assertThat(
289                         toAttr.getCapitalizedPropertiesToTypesMap().keySet(),
290                         is(propsExpected));
291                 propsExpected = new HashSet<String>(2);
292                 propsExpected.add("port");
293                 propsExpected.add("coreSize");
294                 assertThat(toAttr.getJmxPropertiesToTypesMap().keySet(),
295                         is(propsExpected));
296
297                 JavaAttribute timestampAttr = (JavaAttribute) attributeMap
298                         .get("timestamp");
299                 assertNotNull(timestampAttr);
300
301                 JavaAttribute stateAttr = (JavaAttribute) attributeMap
302                         .get("state");
303                 assertNotNull(stateAttr);
304
305                 ListAttribute innerStream = (ListAttribute) attributeMap
306                         .get("inner-stream-list");
307                 assertNotNull(innerStream);
308                 assertThat(innerStream.getAttributeYangName(),
309                         is("inner-stream-list"));
310                 assertThat(innerStream.getLowerCaseCammelCase(),
311                         is("innerStreamList"));
312                 assertThat(innerStream.getUpperCaseCammelCase(),
313                         is("InnerStreamList"));
314                 assertThat(innerStream.getOpenType(), is(ArrayType.class));
315
316             }
317
318         }
319         { // test multiple dependencies
320             ModuleMXBeanEntry threadPoolRegistry = namesToMBEs.get(THREADPOOL_REGISTRY_IMPL_NAME);
321             Map<String, AttributeIfc> attributes = threadPoolRegistry.getAttributes();
322             assertEquals(1, attributes.size());
323             AttributeIfc threadpoolsAttr = attributes.get("threadpools");
324             assertNotNull(threadpoolsAttr);
325             assertTrue(threadpoolsAttr instanceof ListDependenciesAttribute);
326             ListDependenciesAttribute threadpools = (ListDependenciesAttribute) threadpoolsAttr;
327         }
328     }
329
330 }

©2013 OpenDaylight, A Linux Foundation Collaborative Project. All Rights Reserved.
OpenDaylight is a registered trademark of The OpenDaylight Project, Inc.
Linux Foundation and OpenDaylight are registered trademarks of the Linux Foundation.
Linux is a registered trademark of Linus Torvalds.