2 * Copyright (c) 2015 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.yangtools.yang.model.util;
10 import static org.junit.Assert.assertEquals;
11 import static org.junit.Assert.assertTrue;
12 import static org.mockito.Matchers.any;
13 import static org.mockito.Mockito.doReturn;
14 import static org.mockito.Mockito.mock;
16 import com.google.common.collect.ImmutableSet;
18 import java.util.Arrays;
19 import java.util.Collections;
20 import java.util.HashSet;
21 import java.util.List;
22 import java.util.Optional;
24 import org.junit.Test;
25 import org.opendaylight.yangtools.concepts.SemVer;
26 import org.opendaylight.yangtools.yang.common.QName;
27 import org.opendaylight.yangtools.yang.common.QNameModule;
28 import org.opendaylight.yangtools.yang.common.Revision;
29 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
30 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
31 import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
32 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
33 import org.opendaylight.yangtools.yang.model.api.Module;
34 import org.opendaylight.yangtools.yang.model.api.ModuleImport;
35 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
36 import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
37 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
38 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
39 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
40 import org.opendaylight.yangtools.yang.model.util.FilteringSchemaContextProxy.ModuleId;
42 public class SchemaContextProxyTest {
44 private static final URI NAMESPACE = URI.create("urn:opendaylight:params:xml:ns:yang:controller:config");
45 private static final Revision REVISION = Revision.valueOf("2015-01-01");
46 private static final Revision REVISION2 = Revision.valueOf("2015-01-15");
48 private static final String CONFIG_NAME = "config";
49 private static final String ROOT_NAME = "root";
50 private static final String MODULE2_NAME = "module2";
51 private static final String MODULE3_NAME = "module3";
52 private static final String MODULE4_NAME = "module4";
53 private static final String MODULE41_NAME = "module41";
54 private static final String MODULE5_NAME = "module5";
56 private static SchemaContext mockSchema(final Module... module) {
57 SchemaContext mock = mock(SchemaContext.class);
58 doReturn(ImmutableSet.copyOf(module)).when(mock).getModules();
69 public void testBasic() {
70 Module moduleConfig = mockModule(CONFIG_NAME);
71 Module module2 = mockModule(MODULE2_NAME);
72 Module module3 = mockModule(MODULE3_NAME);
74 mockModuleImport(module2, moduleConfig);
75 mockModuleImport(module3, module2, moduleConfig);
77 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
79 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
81 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
85 * No root or additional modules
91 public void testNull() {
92 Module moduleConfig = mockModule(CONFIG_NAME);
93 Module module2 = mockModule(MODULE2_NAME);
94 Module module3 = mockModule(MODULE3_NAME);
96 mockModuleImport(module2, moduleConfig);
97 mockModuleImport(module3, module2, moduleConfig);
99 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
101 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, null);
102 assertProxyContext(filteringSchemaContextProxy, null);
112 public void testConfigDifferentRevisions() {
113 Module moduleConfigNullRevision = mockModule(CONFIG_NAME, null);
114 Module moduleConfig = mockModule(CONFIG_NAME, REVISION);
115 Module moduleConfig2 = mockModule(CONFIG_NAME, REVISION2);
116 Module module2 = mockModule(MODULE2_NAME);
117 Module module3 = mockModule(MODULE3_NAME);
119 mockModuleImport(module2, moduleConfig);
120 mockModuleImport(module3, module2, moduleConfigNullRevision);
122 SchemaContext schemaContext = mockSchema(moduleConfig, moduleConfig2, module2, module3);
124 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
126 assertProxyContext(filteringSchemaContextProxy, moduleConfig, moduleConfig2, module2, module3);
136 public void testBasicNullRevision() throws Exception {
137 final Module moduleConfig = mockModule(CONFIG_NAME, Revision.valueOf("2013-04-05"));
138 final Module module2 = mockModule(MODULE2_NAME, Revision.valueOf("2014-06-17"));
139 final Module module20 = mockModule(MODULE2_NAME, null);
140 final Module module3 = mockModule(MODULE3_NAME, Revision.valueOf("2014-06-12"));
141 final Module module30 = mockModule(MODULE3_NAME, null);
143 mockModuleImport(module20, moduleConfig);
144 mockModuleImport(module2, moduleConfig);
145 mockModuleImport(module3, module20, moduleConfig);
146 mockModuleImport(module30, module20, moduleConfig);
148 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
150 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
153 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
163 public void testBasicMoreRootModules() {
164 final Module moduleConfig = mockModule(CONFIG_NAME);
165 final Module moduleRoot = mockModule(ROOT_NAME);
166 final Module module2 = mockModule(MODULE2_NAME);
167 final Module module3 = mockModule(MODULE3_NAME);
169 mockModuleImport(module2, moduleConfig);
170 mockModuleImport(module3, moduleRoot);
172 SchemaContext schemaContext = mockSchema(moduleConfig, moduleRoot, module2, module3);
174 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleRoot,
176 assertProxyContext(filteringSchemaContextProxy, moduleRoot, module3, moduleConfig, module2);
186 public void testChainNotDepend() {
187 Module moduleConfig = mockModule(CONFIG_NAME);
188 Module module2 = mockModule(MODULE2_NAME);
189 Module module3 = mockModule(MODULE3_NAME);
191 mockModuleImport(module2, moduleConfig);
192 mockModuleImport(module3, module2);
194 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
196 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
198 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2);
205 * M2 -> M3 -> M4 -> M5
208 public void testChainDependMulti() {
209 Module moduleConfig = mockModule(CONFIG_NAME);
210 Module module2 = mockModule(MODULE2_NAME);
211 Module module3 = mockModule(MODULE3_NAME);
212 Module module4 = mockModule(MODULE4_NAME);
213 Module module5 = mockModule(MODULE5_NAME);
215 mockModuleImport(module2, moduleConfig, module3);
216 mockModuleImport(module3, module4);
217 mockModuleImport(module4, module5);
219 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4, module5);
221 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
223 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4, module5);
233 public void testChainNotDependMulti() {
234 Module moduleConfig = mockModule(CONFIG_NAME);
235 Module module2 = mockModule(MODULE2_NAME);
236 Module module3 = mockModule(MODULE3_NAME);
237 Module module4 = mockModule(MODULE4_NAME);
239 mockModuleImport(module2, moduleConfig, module3);
240 mockModuleImport(module4, module3);
242 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4);
244 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
246 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
256 public void testChainNotMulti() {
257 final Module moduleConfig = mockModule(CONFIG_NAME);
258 final Module module2 = mockModule(MODULE2_NAME);
259 final Module module3 = mockModule(MODULE3_NAME);
260 final Module module4 = mockModule(MODULE4_NAME);
261 final Module module5 = mockModule(MODULE5_NAME);
263 mockModuleImport(module2, moduleConfig);
264 mockModuleImport(module3, moduleConfig);
265 mockModuleImport(module4, moduleConfig);
266 mockModuleImport(module5, moduleConfig);
268 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4, module5);
270 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
272 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4, module5);
279 * M2 <- M3 M4=M3(Different revision)
282 public void testBasicRevisionChange() throws Exception {
283 Module moduleConfig = mockModule(CONFIG_NAME);
284 Module module2 = mockModule(MODULE2_NAME);
285 Module module3 = mockModule(MODULE3_NAME);
286 Module module4 = mockModule(MODULE3_NAME, Revision.valueOf("2015-10-10"));
288 mockModuleImport(module2, moduleConfig);
289 mockModuleImport(module3, module2, moduleConfig);
291 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4);
293 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
295 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
301 * M2 -(no revision)-> M3(R2) ... M3(R1)
304 public void testImportNoRevision() {
305 Module moduleConfig = mockModule(CONFIG_NAME, REVISION);
306 Module module2 = mockModule(MODULE2_NAME, REVISION);
308 Module module3 = mockModule(MODULE3_NAME, null);
309 Module module30 = mockModule(MODULE3_NAME, REVISION);
310 Module module31 = mockModule(MODULE3_NAME, REVISION2);
311 mockModuleImport(module2, moduleConfig, module3);
313 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module30, module31);
315 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
318 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module31);
330 public void testBasicSubmodule() {
331 Module moduleConfig = mockModule(CONFIG_NAME);
332 Module module2 = mockModule(MODULE2_NAME);
333 Module module3 = mockModule(MODULE3_NAME);
334 Module module4 = mockModule(MODULE4_NAME);
335 Module module41 = mockModule(MODULE41_NAME);
337 mockSubmodules(module4, module41);
338 mockModuleImport(module2, moduleConfig, module3);
339 mockModuleImport(module41, moduleConfig);
341 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4);
343 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
345 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4);
349 * M2 -> M3 -> M4 -> M5
352 public void testChainAdditionalModules() {
353 Module module2 = mockModule(MODULE2_NAME);
354 Module module3 = mockModule(MODULE3_NAME);
355 Module module4 = mockModule(MODULE4_NAME);
356 Module module5 = mockModule(MODULE5_NAME);
358 mockModuleImport(module2, module3);
359 mockModuleImport(module3, module4);
360 mockModuleImport(module4, module5);
362 SchemaContext schemaContext = mockSchema(module2, module3, module4, module5);
364 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
365 Collections.singleton(module2), null);
366 assertProxyContext(filteringSchemaContextProxy, module2, module3, module4, module5);
379 public void testChainAdditionalModulesConfig() {
380 Module moduleConfig = mockModule(CONFIG_NAME);
381 Module module2 = mockModule(MODULE2_NAME);
383 Module module3 = mockModule(MODULE3_NAME);
384 Module module4 = mockModule(MODULE4_NAME);
385 Module module5 = mockModule(MODULE5_NAME);
387 mockModuleImport(module2, moduleConfig);
388 mockModuleImport(module3, module4);
390 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4, module5);
392 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
393 Collections.singleton(module3), moduleConfig);
394 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4);
398 public void testGetDataDefinitions() {
399 final Module moduleConfig = mockModule(CONFIG_NAME);
400 final SchemaContext schemaContext = mockSchema(moduleConfig);
401 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
402 new HashSet<>(), moduleConfig);
404 final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class);
405 final Set<DataSchemaNode> childNodes = Collections.singleton(mockedContainer);
406 doReturn(childNodes).when(moduleConfig).getChildNodes();
408 final Set<DataSchemaNode> dataDefinitions = filteringSchemaContextProxy.getDataDefinitions();
409 assertTrue(dataDefinitions.contains(mockedContainer));
413 public void testGetNotifications() {
414 final Module moduleConfig = mockModule(CONFIG_NAME);
415 final SchemaContext schemaContext = mockSchema(moduleConfig);
416 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
417 new HashSet<>(), moduleConfig);
419 final NotificationDefinition mockedNotification = mock(NotificationDefinition.class);
420 final Set<NotificationDefinition> notifications = Collections.singleton(mockedNotification);
421 doReturn(notifications).when(moduleConfig).getNotifications();
423 final Set<NotificationDefinition> schemaContextProxyNotifications =
424 filteringSchemaContextProxy.getNotifications();
425 assertTrue(schemaContextProxyNotifications.contains(mockedNotification));
429 public void testGetOperations() {
430 final Module moduleConfig = mockModule(CONFIG_NAME);
431 final SchemaContext schemaContext = mockSchema(moduleConfig);
432 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
433 new HashSet<>(), moduleConfig);
435 final RpcDefinition mockedRpc = mock(RpcDefinition.class);
436 final Set<RpcDefinition> rpcs = Collections.singleton(mockedRpc);
437 doReturn(rpcs).when(moduleConfig).getRpcs();
439 final Set<RpcDefinition> operations = filteringSchemaContextProxy.getOperations();
440 assertTrue(operations.contains(mockedRpc));
444 public void testGetExtensions() {
445 final Module moduleConfig = mockModule(CONFIG_NAME);
446 final SchemaContext schemaContext = mockSchema(moduleConfig);
447 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
448 new HashSet<>(), moduleConfig);
450 final ExtensionDefinition mockedExtension = mock(ExtensionDefinition.class);
451 final List<ExtensionDefinition> extensions = Collections.singletonList(mockedExtension);
452 doReturn(extensions).when(moduleConfig).getExtensionSchemaNodes();
454 final Set<ExtensionDefinition> schemaContextProxyExtensions = filteringSchemaContextProxy.getExtensions();
455 assertTrue(schemaContextProxyExtensions.contains(mockedExtension));
459 public void testGetUnknownSchemaNodes() {
460 final Module moduleConfig = mockModule(CONFIG_NAME);
461 final SchemaContext schemaContext = mockSchema(moduleConfig);
462 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
463 new HashSet<>(), moduleConfig);
465 final UnknownSchemaNode mockedUnknownSchemaNode = mock(UnknownSchemaNode.class);
466 final List<UnknownSchemaNode> unknownSchemaNodes = Collections.singletonList(mockedUnknownSchemaNode);
467 doReturn(unknownSchemaNodes).when(moduleConfig).getUnknownSchemaNodes();
469 final List<UnknownSchemaNode> schemaContextProxyUnknownSchemaNodes =
470 filteringSchemaContextProxy.getUnknownSchemaNodes();
471 assertTrue(schemaContextProxyUnknownSchemaNodes.contains(mockedUnknownSchemaNode));
475 public void testGetTypeDefinitions() {
476 final Module moduleConfig = mockModule(CONFIG_NAME);
477 final SchemaContext schemaContext = mockSchema(moduleConfig);
478 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
479 new HashSet<>(), moduleConfig);
481 final TypeDefinition<?> mockedTypeDefinition = mock(TypeDefinition.class);
482 final Set<TypeDefinition<?>> typeDefinitions = Collections.singleton(mockedTypeDefinition);
483 doReturn(typeDefinitions).when(moduleConfig).getTypeDefinitions();
485 final Set<TypeDefinition<?>> schemaContextProxyTypeDefinitions = filteringSchemaContextProxy
486 .getTypeDefinitions();
487 assertTrue(schemaContextProxyTypeDefinitions.contains(mockedTypeDefinition));
491 public void testGetChildNodes() {
492 final Module moduleConfig = mockModule(CONFIG_NAME);
493 final SchemaContext schemaContext = mockSchema(moduleConfig);
494 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
495 new HashSet<>(), moduleConfig);
497 final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class);
498 final Set<DataSchemaNode> childNodes = Collections.singleton(mockedContainer);
499 doReturn(childNodes).when(moduleConfig).getChildNodes();
501 final Set<DataSchemaNode> schemaContextProxyChildNodes = filteringSchemaContextProxy.getChildNodes();
502 assertTrue(schemaContextProxyChildNodes.contains(mockedContainer));
506 public void testGetGroupings() {
507 final Module moduleConfig = mockModule(CONFIG_NAME);
508 final SchemaContext schemaContext = mockSchema(moduleConfig);
509 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
510 new HashSet<>(), moduleConfig);
512 final GroupingDefinition mockedGrouping = mock(GroupingDefinition.class);
513 final Set<GroupingDefinition> groupings = Collections.singleton(mockedGrouping);
514 doReturn(groupings).when(moduleConfig).getGroupings();
516 final Set<GroupingDefinition> schemaContextProxyGroupings = filteringSchemaContextProxy.getGroupings();
517 assertTrue(schemaContextProxyGroupings.contains(mockedGrouping));
521 public void testGetDataChildByName() {
522 final Module moduleConfig = mockModule(CONFIG_NAME);
523 final SchemaContext schemaContext = mockSchema(moduleConfig);
524 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
525 new HashSet<>(), moduleConfig);
527 final QName qname = QName.create("config-namespace", "2016-08-11", "cont");
528 final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class);
529 doReturn(mockedContainer).when(moduleConfig).getDataChildByName(any(QName.class));
531 final DataSchemaNode dataSchemaNode = filteringSchemaContextProxy.getDataChildByName(qname);
532 assertTrue(dataSchemaNode instanceof ContainerSchemaNode);
535 private static void assertProxyContext(final FilteringSchemaContextProxy filteringSchemaContextProxy,
536 final Module... expected) {
538 final Set<Module> modSet = expected != null ? ImmutableSet.copyOf(expected) : new HashSet<>();
539 Set<Module> modSetFiltering = filteringSchemaContextProxy.getModules();
541 assertEquals(modSet, modSetFiltering);
543 //asserting collections
544 if (expected != null) {
545 for (final Module module : expected) {
546 assertEquals(module, filteringSchemaContextProxy.findModule(module.getName(), module.getRevision())
549 Set<Module> mod = filteringSchemaContextProxy.findModules(module.getNamespace());
550 assertTrue(mod.contains(module));
551 assertEquals(module, filteringSchemaContextProxy.findModule(module.getNamespace(),
552 module.getRevision().orElse(null)).get());
557 private static FilteringSchemaContextProxy createProxySchemaCtx(final SchemaContext schemaContext,
558 final Set<Module> additionalModules, final Module... modules) {
559 Set<Module> modulesSet = new HashSet<>();
560 if (modules != null) {
561 modulesSet = ImmutableSet.copyOf(modules);
564 return new FilteringSchemaContextProxy(schemaContext, createModuleIds(modulesSet),
565 createModuleIds(additionalModules));
568 private static Set<ModuleId> createModuleIds(final Set<Module> modules) {
569 Set<ModuleId> moduleIds = new HashSet<>();
570 if (modules != null) {
571 for (Module module : modules) {
572 moduleIds.add(new ModuleId(module.getName(), module.getRevision()));
579 private static void mockSubmodules(final Module mainModule, final Module... submodules) {
580 Set<Module> submodulesSet = new HashSet<>();
581 submodulesSet.addAll(Arrays.asList(submodules));
583 doReturn(submodulesSet).when(mainModule).getSubmodules();
586 private static void mockModuleImport(final Module importer, final Module... imports) {
587 Set<ModuleImport> mockedImports = new HashSet<>();
588 for (final Module module : imports) {
589 mockedImports.add(new ModuleImport() {
591 public String getModuleName() {
592 return module.getName();
596 public Optional<Revision> getRevision() {
597 return module.getRevision();
601 public String getPrefix() {
602 return module.getName();
606 public Optional<SemVer> getSemanticVersion() {
607 return module.getSemanticVersion();
611 public String toString() {
612 return String.format("Module: %s, revision:%s", module.getName(), module.getRevision());
616 doReturn(mockedImports).when(importer).getImports();
619 //mock module with revision
620 private static Module mockModule(final String name, final Revision rev) {
622 final Module mod = mockModule(name);
624 doReturn(QNameModule.create(mod.getNamespace(), rev)).when(mod).getQNameModule();
625 doReturn(Optional.ofNullable(rev)).when(mod).getRevision();
626 doReturn(mod.getQNameModule().toString()).when(mod).toString();
631 //mock module with default revision
632 private static Module mockModule(final String name) {
634 Module mockedModule = mock(Module.class);
635 doReturn(name).when(mockedModule).getName();
636 doReturn(Optional.of(REVISION)).when(mockedModule).getRevision();
637 final URI newNamespace = URI.create(NAMESPACE.toString() + ":" + name);
638 doReturn(newNamespace).when(mockedModule).getNamespace();
639 doReturn(QNameModule.create(newNamespace, REVISION)).when(mockedModule).getQNameModule();
640 doReturn(new HashSet<>()).when(mockedModule).getSubmodules();
641 doReturn(mockedModule.getQNameModule().toString()).when(mockedModule).toString();
642 mockModuleImport(mockedModule);