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.of("2015-01-01");
46 private static final Revision REVISION2 = Revision.of("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... modules) {
57 final List<Module> sortedModules = Arrays.asList(modules);
58 sortedModules.sort(AbstractSchemaContext.NAME_REVISION_COMPARATOR);
59 SchemaContext mock = mock(SchemaContext.class);
60 doReturn(ImmutableSet.copyOf(sortedModules)).when(mock).getModules();
71 public void testBasic() {
72 Module moduleConfig = mockModule(CONFIG_NAME);
73 Module module2 = mockModule(MODULE2_NAME);
74 Module module3 = mockModule(MODULE3_NAME);
76 mockModuleImport(module2, moduleConfig);
77 mockModuleImport(module3, module2, moduleConfig);
79 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
81 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
83 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
87 * No root or additional modules
93 public void testNull() {
94 Module moduleConfig = mockModule(CONFIG_NAME);
95 Module module2 = mockModule(MODULE2_NAME);
96 Module module3 = mockModule(MODULE3_NAME);
98 mockModuleImport(module2, moduleConfig);
99 mockModuleImport(module3, module2, moduleConfig);
101 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
103 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, null);
104 assertProxyContext(filteringSchemaContextProxy, null);
114 public void testConfigDifferentRevisions() {
115 Module moduleConfigNullRevision = mockModule(CONFIG_NAME, null);
116 Module moduleConfig = mockModule(CONFIG_NAME, REVISION);
117 Module moduleConfig2 = mockModule(CONFIG_NAME, REVISION2);
118 Module module2 = mockModule(MODULE2_NAME);
119 Module module3 = mockModule(MODULE3_NAME);
121 mockModuleImport(module2, moduleConfig);
122 mockModuleImport(module3, module2, moduleConfigNullRevision);
124 SchemaContext schemaContext = mockSchema(moduleConfig, moduleConfig2, module2, module3);
126 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
128 assertProxyContext(filteringSchemaContextProxy, moduleConfig, moduleConfig2, module2, module3);
138 public void testBasicNullRevision() throws Exception {
139 final Module moduleConfig = mockModule(CONFIG_NAME, Revision.of("2013-04-05"));
140 final Module module2 = mockModule(MODULE2_NAME, Revision.of("2014-06-17"));
141 final Module module20 = mockModule(MODULE2_NAME, null);
142 final Module module3 = mockModule(MODULE3_NAME, Revision.of("2014-06-12"));
143 final Module module30 = mockModule(MODULE3_NAME, null);
145 mockModuleImport(module20, moduleConfig);
146 mockModuleImport(module2, moduleConfig);
147 mockModuleImport(module3, module20, moduleConfig);
148 mockModuleImport(module30, module20, moduleConfig);
150 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
152 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
155 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
165 public void testBasicMoreRootModules() {
166 final Module moduleConfig = mockModule(CONFIG_NAME);
167 final Module moduleRoot = mockModule(ROOT_NAME);
168 final Module module2 = mockModule(MODULE2_NAME);
169 final Module module3 = mockModule(MODULE3_NAME);
171 mockModuleImport(module2, moduleConfig);
172 mockModuleImport(module3, moduleRoot);
174 SchemaContext schemaContext = mockSchema(moduleConfig, moduleRoot, module2, module3);
176 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleRoot,
178 assertProxyContext(filteringSchemaContextProxy, moduleRoot, module3, moduleConfig, module2);
188 public void testChainNotDepend() {
189 Module moduleConfig = mockModule(CONFIG_NAME);
190 Module module2 = mockModule(MODULE2_NAME);
191 Module module3 = mockModule(MODULE3_NAME);
193 mockModuleImport(module2, moduleConfig);
194 mockModuleImport(module3, module2);
196 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
198 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
200 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2);
207 * M2 -> M3 -> M4 -> M5
210 public void testChainDependMulti() {
211 Module moduleConfig = mockModule(CONFIG_NAME);
212 Module module2 = mockModule(MODULE2_NAME);
213 Module module3 = mockModule(MODULE3_NAME);
214 Module module4 = mockModule(MODULE4_NAME);
215 Module module5 = mockModule(MODULE5_NAME);
217 mockModuleImport(module2, moduleConfig, module3);
218 mockModuleImport(module3, module4);
219 mockModuleImport(module4, module5);
221 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4, module5);
223 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
225 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4, module5);
235 public void testChainNotDependMulti() {
236 Module moduleConfig = mockModule(CONFIG_NAME);
237 Module module2 = mockModule(MODULE2_NAME);
238 Module module3 = mockModule(MODULE3_NAME);
239 Module module4 = mockModule(MODULE4_NAME);
241 mockModuleImport(module2, moduleConfig, module3);
242 mockModuleImport(module4, module3);
244 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4);
246 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
248 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
258 public void testChainNotMulti() {
259 final Module moduleConfig = mockModule(CONFIG_NAME);
260 final Module module2 = mockModule(MODULE2_NAME);
261 final Module module3 = mockModule(MODULE3_NAME);
262 final Module module4 = mockModule(MODULE4_NAME);
263 final Module module5 = mockModule(MODULE5_NAME);
265 mockModuleImport(module2, moduleConfig);
266 mockModuleImport(module3, moduleConfig);
267 mockModuleImport(module4, moduleConfig);
268 mockModuleImport(module5, moduleConfig);
270 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4, module5);
272 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
274 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4, module5);
281 * M2 <- M3 M4=M3(Different revision)
284 public void testBasicRevisionChange() throws Exception {
285 Module moduleConfig = mockModule(CONFIG_NAME);
286 Module module2 = mockModule(MODULE2_NAME);
287 Module module3 = mockModule(MODULE3_NAME);
288 Module module4 = mockModule(MODULE3_NAME, Revision.of("2015-10-10"));
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(Optional.of(mockedContainer)).when(moduleConfig).findDataChildByName(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().orElse(null)).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 Optional<Revision> getRevision() {
599 return module.getRevision();
603 public String getPrefix() {
604 return module.getName();
608 public Optional<SemVer> getSemanticVersion() {
609 return module.getSemanticVersion();
613 public Optional<String> getDescription() {
614 return module.getDescription();
618 public Optional<String> getReference() {
619 return module.getReference();
623 public String toString() {
624 return String.format("Module: %s, revision:%s", module.getName(), module.getRevision());
628 doReturn(mockedImports).when(importer).getImports();
631 //mock module with revision
632 private static Module mockModule(final String name, final Revision rev) {
634 final Module mod = mockModule(name);
636 doReturn(QNameModule.create(mod.getNamespace(), rev)).when(mod).getQNameModule();
637 doReturn(Optional.ofNullable(rev)).when(mod).getRevision();
638 doReturn(mod.getQNameModule().toString()).when(mod).toString();
643 //mock module with default revision
644 private static Module mockModule(final String name) {
646 Module mockedModule = mock(Module.class);
647 doReturn(name).when(mockedModule).getName();
648 doReturn(Optional.of(REVISION)).when(mockedModule).getRevision();
649 final URI newNamespace = URI.create(NAMESPACE.toString() + ":" + name);
650 doReturn(newNamespace).when(mockedModule).getNamespace();
651 doReturn(QNameModule.create(newNamespace, REVISION)).when(mockedModule).getQNameModule();
652 doReturn(new HashSet<>()).when(mockedModule).getSubmodules();
653 doReturn(mockedModule.getQNameModule().toString()).when(mockedModule).toString();
654 mockModuleImport(mockedModule);