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.Date;
21 import java.util.HashSet;
22 import java.util.List;
23 import java.util.Optional;
25 import org.junit.Test;
26 import org.opendaylight.yangtools.concepts.SemVer;
27 import org.opendaylight.yangtools.yang.common.QName;
28 import org.opendaylight.yangtools.yang.common.QNameModule;
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 Date REVISION = QName.parseRevision("2015-01-01");
46 private static final Date REVISION2 = QName.parseRevision("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, QName.parseRevision("2013-04-05"));
138 final Module module2 = mockModule(MODULE2_NAME, QName.parseRevision("2014-06-17"));
139 final Module module20 = mockModule(MODULE2_NAME, null);
140 final Module module3 = mockModule(MODULE3_NAME, QName.parseRevision("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);
287 Date dat = QName.parseRevision("2015-10-10");
288 Module module4 = mockModule(MODULE3_NAME, dat);
290 mockModuleImport(module2, moduleConfig);
291 mockModuleImport(module3, module2, moduleConfig);
293 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4);
295 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
297 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
303 * M2 -(no revision)-> M3(R2) ... M3(R1)
306 public void testImportNoRevision() {
307 Module moduleConfig = mockModule(CONFIG_NAME, REVISION);
308 Module module2 = mockModule(MODULE2_NAME, REVISION);
310 Module module3 = mockModule(MODULE3_NAME, null);
311 Module module30 = mockModule(MODULE3_NAME, REVISION);
312 Module module31 = mockModule(MODULE3_NAME, REVISION2);
313 mockModuleImport(module2, moduleConfig, module3);
315 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module30, module31);
317 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
320 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module31);
332 public void testBasicSubmodule() {
333 Module moduleConfig = mockModule(CONFIG_NAME);
334 Module module2 = mockModule(MODULE2_NAME);
335 Module module3 = mockModule(MODULE3_NAME);
336 Module module4 = mockModule(MODULE4_NAME);
337 Module module41 = mockModule(MODULE41_NAME);
339 mockSubmodules(module4, module41);
340 mockModuleImport(module2, moduleConfig, module3);
341 mockModuleImport(module41, moduleConfig);
343 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4);
345 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
347 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4);
351 * M2 -> M3 -> M4 -> M5
354 public void testChainAdditionalModules() {
355 Module module2 = mockModule(MODULE2_NAME);
356 Module module3 = mockModule(MODULE3_NAME);
357 Module module4 = mockModule(MODULE4_NAME);
358 Module module5 = mockModule(MODULE5_NAME);
360 mockModuleImport(module2, module3);
361 mockModuleImport(module3, module4);
362 mockModuleImport(module4, module5);
364 SchemaContext schemaContext = mockSchema(module2, module3, module4, module5);
366 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
367 Collections.singleton(module2), null);
368 assertProxyContext(filteringSchemaContextProxy, module2, module3, module4, module5);
381 public void testChainAdditionalModulesConfig() {
382 Module moduleConfig = mockModule(CONFIG_NAME);
383 Module module2 = mockModule(MODULE2_NAME);
385 Module module3 = mockModule(MODULE3_NAME);
386 Module module4 = mockModule(MODULE4_NAME);
387 Module module5 = mockModule(MODULE5_NAME);
389 mockModuleImport(module2, moduleConfig);
390 mockModuleImport(module3, module4);
392 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4, module5);
394 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
395 Collections.singleton(module3), moduleConfig);
396 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4);
400 public void testGetDataDefinitions() {
401 final Module moduleConfig = mockModule(CONFIG_NAME);
402 final SchemaContext schemaContext = mockSchema(moduleConfig);
403 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
404 new HashSet<>(), moduleConfig);
406 final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class);
407 final Set<DataSchemaNode> childNodes = Collections.singleton(mockedContainer);
408 doReturn(childNodes).when(moduleConfig).getChildNodes();
410 final Set<DataSchemaNode> dataDefinitions = filteringSchemaContextProxy.getDataDefinitions();
411 assertTrue(dataDefinitions.contains(mockedContainer));
415 public void testGetNotifications() {
416 final Module moduleConfig = mockModule(CONFIG_NAME);
417 final SchemaContext schemaContext = mockSchema(moduleConfig);
418 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
419 new HashSet<>(), moduleConfig);
421 final NotificationDefinition mockedNotification = mock(NotificationDefinition.class);
422 final Set<NotificationDefinition> notifications = Collections.singleton(mockedNotification);
423 doReturn(notifications).when(moduleConfig).getNotifications();
425 final Set<NotificationDefinition> schemaContextProxyNotifications =
426 filteringSchemaContextProxy.getNotifications();
427 assertTrue(schemaContextProxyNotifications.contains(mockedNotification));
431 public void testGetOperations() {
432 final Module moduleConfig = mockModule(CONFIG_NAME);
433 final SchemaContext schemaContext = mockSchema(moduleConfig);
434 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
435 new HashSet<>(), moduleConfig);
437 final RpcDefinition mockedRpc = mock(RpcDefinition.class);
438 final Set<RpcDefinition> rpcs = Collections.singleton(mockedRpc);
439 doReturn(rpcs).when(moduleConfig).getRpcs();
441 final Set<RpcDefinition> operations = filteringSchemaContextProxy.getOperations();
442 assertTrue(operations.contains(mockedRpc));
446 public void testGetExtensions() {
447 final Module moduleConfig = mockModule(CONFIG_NAME);
448 final SchemaContext schemaContext = mockSchema(moduleConfig);
449 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
450 new HashSet<>(), moduleConfig);
452 final ExtensionDefinition mockedExtension = mock(ExtensionDefinition.class);
453 final List<ExtensionDefinition> extensions = Collections.singletonList(mockedExtension);
454 doReturn(extensions).when(moduleConfig).getExtensionSchemaNodes();
456 final Set<ExtensionDefinition> schemaContextProxyExtensions = filteringSchemaContextProxy.getExtensions();
457 assertTrue(schemaContextProxyExtensions.contains(mockedExtension));
461 public void testGetUnknownSchemaNodes() {
462 final Module moduleConfig = mockModule(CONFIG_NAME);
463 final SchemaContext schemaContext = mockSchema(moduleConfig);
464 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
465 new HashSet<>(), moduleConfig);
467 final UnknownSchemaNode mockedUnknownSchemaNode = mock(UnknownSchemaNode.class);
468 final List<UnknownSchemaNode> unknownSchemaNodes = Collections.singletonList(mockedUnknownSchemaNode);
469 doReturn(unknownSchemaNodes).when(moduleConfig).getUnknownSchemaNodes();
471 final List<UnknownSchemaNode> schemaContextProxyUnknownSchemaNodes =
472 filteringSchemaContextProxy.getUnknownSchemaNodes();
473 assertTrue(schemaContextProxyUnknownSchemaNodes.contains(mockedUnknownSchemaNode));
477 public void testGetTypeDefinitions() {
478 final Module moduleConfig = mockModule(CONFIG_NAME);
479 final SchemaContext schemaContext = mockSchema(moduleConfig);
480 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
481 new HashSet<>(), moduleConfig);
483 final TypeDefinition<?> mockedTypeDefinition = mock(TypeDefinition.class);
484 final Set<TypeDefinition<?>> typeDefinitions = Collections.singleton(mockedTypeDefinition);
485 doReturn(typeDefinitions).when(moduleConfig).getTypeDefinitions();
487 final Set<TypeDefinition<?>> schemaContextProxyTypeDefinitions = filteringSchemaContextProxy
488 .getTypeDefinitions();
489 assertTrue(schemaContextProxyTypeDefinitions.contains(mockedTypeDefinition));
493 public void testGetChildNodes() {
494 final Module moduleConfig = mockModule(CONFIG_NAME);
495 final SchemaContext schemaContext = mockSchema(moduleConfig);
496 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
497 new HashSet<>(), moduleConfig);
499 final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class);
500 final Set<DataSchemaNode> childNodes = Collections.singleton(mockedContainer);
501 doReturn(childNodes).when(moduleConfig).getChildNodes();
503 final Set<DataSchemaNode> schemaContextProxyChildNodes = filteringSchemaContextProxy.getChildNodes();
504 assertTrue(schemaContextProxyChildNodes.contains(mockedContainer));
508 public void testGetGroupings() {
509 final Module moduleConfig = mockModule(CONFIG_NAME);
510 final SchemaContext schemaContext = mockSchema(moduleConfig);
511 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
512 new HashSet<>(), moduleConfig);
514 final GroupingDefinition mockedGrouping = mock(GroupingDefinition.class);
515 final Set<GroupingDefinition> groupings = Collections.singleton(mockedGrouping);
516 doReturn(groupings).when(moduleConfig).getGroupings();
518 final Set<GroupingDefinition> schemaContextProxyGroupings = filteringSchemaContextProxy.getGroupings();
519 assertTrue(schemaContextProxyGroupings.contains(mockedGrouping));
523 public void testGetDataChildByName() {
524 final Module moduleConfig = mockModule(CONFIG_NAME);
525 final SchemaContext schemaContext = mockSchema(moduleConfig);
526 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
527 new HashSet<>(), moduleConfig);
529 final QName qname = QName.create("config-namespace", "2016-08-11", "cont");
530 final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class);
531 doReturn(mockedContainer).when(moduleConfig).getDataChildByName(any(QName.class));
533 final DataSchemaNode dataSchemaNode = filteringSchemaContextProxy.getDataChildByName(qname);
534 assertTrue(dataSchemaNode instanceof ContainerSchemaNode);
537 private static void assertProxyContext(final FilteringSchemaContextProxy filteringSchemaContextProxy,
538 final Module... expected) {
540 final Set<Module> modSet = expected != null ? ImmutableSet.copyOf(expected) : new HashSet<>();
541 Set<Module> modSetFiltering = filteringSchemaContextProxy.getModules();
543 assertEquals(modSet, modSetFiltering);
545 //asserting collections
546 if (expected != null) {
547 for (final Module module : expected) {
548 assertEquals(module, filteringSchemaContextProxy.findModule(module.getName(), module.getRevision())
551 Set<Module> mod = filteringSchemaContextProxy.findModules(module.getNamespace());
552 assertTrue(mod.contains(module));
553 assertEquals(module, filteringSchemaContextProxy.findModule(module.getNamespace(),
554 module.getRevision()).get());
559 private static FilteringSchemaContextProxy createProxySchemaCtx(final SchemaContext schemaContext,
560 final Set<Module> additionalModules, final Module... modules) {
561 Set<Module> modulesSet = new HashSet<>();
562 if (modules != null) {
563 modulesSet = ImmutableSet.copyOf(modules);
566 return new FilteringSchemaContextProxy(schemaContext, createModuleIds(modulesSet),
567 createModuleIds(additionalModules));
570 private static Set<ModuleId> createModuleIds(final Set<Module> modules) {
571 Set<ModuleId> moduleIds = new HashSet<>();
572 if (modules != null) {
573 for (Module module : modules) {
574 moduleIds.add(new ModuleId(module.getName(), module.getRevision()));
581 private static void mockSubmodules(final Module mainModule, final Module... submodules) {
582 Set<Module> submodulesSet = new HashSet<>();
583 submodulesSet.addAll(Arrays.asList(submodules));
585 doReturn(submodulesSet).when(mainModule).getSubmodules();
588 private static void mockModuleImport(final Module importer, final Module... imports) {
589 Set<ModuleImport> mockedImports = new HashSet<>();
590 for (final Module module : imports) {
591 mockedImports.add(new ModuleImport() {
593 public String getModuleName() {
594 return module.getName();
598 public Date getRevision() {
599 return module.getRevision();
603 public String getPrefix() {
604 return module.getName();
608 public Optional<SemVer> getSemanticVersion() {
609 return module.getSemanticVersion();
613 public String toString() {
614 return String.format("Module: %s, revision:%s", module.getName(), module.getRevision());
618 doReturn(mockedImports).when(importer).getImports();
621 //mock module with revision
622 private static Module mockModule(final String name, final Date rev) {
624 final Module mod = mockModule(name);
626 doReturn(QNameModule.create(mod.getNamespace(), rev)).when(mod).getQNameModule();
627 doReturn(rev).when(mod).getRevision();
628 doReturn(mod.getQNameModule().toString()).when(mod).toString();
633 //mock module with default revision
634 private static Module mockModule(final String name) {
636 Module mockedModule = mock(Module.class);
637 doReturn(name).when(mockedModule).getName();
638 doReturn(REVISION).when(mockedModule).getRevision();
639 final URI newNamespace = URI.create(NAMESPACE.toString() + ":" + name);
640 doReturn(newNamespace).when(mockedModule).getNamespace();
641 doReturn(QNameModule.create(newNamespace, REVISION)).when(mockedModule).getQNameModule();
642 doReturn(new HashSet<>()).when(mockedModule).getSubmodules();
643 doReturn(mockedModule.getQNameModule().toString()).when(mockedModule).toString();
644 mockModuleImport(mockedModule);