yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/SchemaContextProxyTest.java

   1 /*
   2  * Copyright (c) 2015 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.yangtools.yang.model.util;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertTrue;
  12 import static org.mockito.ArgumentMatchers.any;
  13 import static org.mockito.Mockito.doReturn;
  14 import static org.mockito.Mockito.mock;
  15
  16 import com.google.common.collect.ImmutableSet;
  17 import java.net.URI;
  18 import java.util.Arrays;
  19 import java.util.Collection;
  20 import java.util.Collections;
  21 import java.util.HashSet;
  22 import java.util.List;
  23 import java.util.Optional;
  24 import java.util.Set;
  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.common.Revision;
  30 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
  31 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  32 import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
  33 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
  34 import org.opendaylight.yangtools.yang.model.api.Module;
  35 import org.opendaylight.yangtools.yang.model.api.ModuleImport;
  36 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
  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.TypeDefinition;
  40 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
  41 import org.opendaylight.yangtools.yang.model.api.stmt.ImportEffectiveStatement;
  42 import org.opendaylight.yangtools.yang.model.util.FilteringSchemaContextProxy.ModuleId;
  43
  44 public class SchemaContextProxyTest {
  45
  46     private static final URI NAMESPACE = URI.create("urn:opendaylight:params:xml:ns:yang:controller:config");
  47     private static final Revision REVISION = Revision.of("2015-01-01");
  48     private static final Revision REVISION2 = Revision.of("2015-01-15");
  49
  50     private static final String CONFIG_NAME = "config";
  51     private static final String ROOT_NAME = "root";
  52     private static final String MODULE2_NAME = "module2";
  53     private static final String MODULE3_NAME = "module3";
  54     private static final String MODULE4_NAME = "module4";
  55     private static final String MODULE41_NAME = "module41";
  56     private static final String MODULE5_NAME = "module5";
  57
  58     private static SchemaContext mockSchema(final Module... modules) {
  59         final List<Module> sortedModules = Arrays.asList(modules);
  60         sortedModules.sort(AbstractSchemaContext.NAME_REVISION_COMPARATOR);
  61         SchemaContext mock = mock(SchemaContext.class);
  62         doReturn(ImmutableSet.copyOf(sortedModules)).when(mock).getModules();
  63         return mock;
  64     }
  65
  66     /*
  67      * CFG(R)
  68      *  | \
  69      *  |  \
  70      * M2 <- M3
  71      */
  72     @Test
  73     public void testBasic() {
  74         Module moduleConfig = mockModule(CONFIG_NAME);
  75         Module module2 = mockModule(MODULE2_NAME);
  76         Module module3 = mockModule(MODULE3_NAME);
  77
  78         mockModuleImport(module2, moduleConfig);
  79         mockModuleImport(module3, module2, moduleConfig);
  80
  81         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
  82
  83         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
  84                 moduleConfig);
  85         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
  86     }
  87
  88     /*
  89      * No root or additional modules
  90      *  | \
  91      *  |  \
  92      * M2 <- M3
  93      */
  94     @Test
  95     public void testNull() {
  96         Module moduleConfig = mockModule(CONFIG_NAME);
  97         Module module2 = mockModule(MODULE2_NAME);
  98         Module module3 = mockModule(MODULE3_NAME);
  99
 100         mockModuleImport(module2, moduleConfig);
 101         mockModuleImport(module3, module2, moduleConfig);
 102
 103         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
 104
 105         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, null);
 106         assertProxyContext(filteringSchemaContextProxy, null);
 107     }
 108
 109     /*
 110      *  Config
 111      *  | \ (NR)
 112      *  |  \
 113      * M2 <- M3
 114      */
 115     @Test
 116     public void testConfigDifferentRevisions() {
 117         Module moduleConfigNullRevision = mockModule(CONFIG_NAME, null);
 118         Module moduleConfig = mockModule(CONFIG_NAME, REVISION);
 119         Module moduleConfig2 = mockModule(CONFIG_NAME, REVISION2);
 120         Module module2 = mockModule(MODULE2_NAME);
 121         Module module3 = mockModule(MODULE3_NAME);
 122
 123         mockModuleImport(module2, moduleConfig);
 124         mockModuleImport(module3, module2, moduleConfigNullRevision);
 125
 126         SchemaContext schemaContext = mockSchema(moduleConfig, moduleConfig2, module2, module3);
 127
 128         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
 129                 moduleConfig);
 130         assertProxyContext(filteringSchemaContextProxy, moduleConfig, moduleConfig2, module2, module3);
 131     }
 132
 133     /*
 134      *     CFG(R)
 135      *    |      \
 136      *   |         \
 137      * M2<-(NullRev)M3
 138      */
 139     @Test
 140     public void testBasicNullRevision() throws Exception {
 141         final Module moduleConfig = mockModule(CONFIG_NAME, Revision.of("2013-04-05"));
 142         final Module module2 = mockModule(MODULE2_NAME, Revision.of("2014-06-17"));
 143         final Module module20 = mockModule(MODULE2_NAME, null);
 144         final Module module3 = mockModule(MODULE3_NAME, Revision.of("2014-06-12"));
 145         final Module module30 = mockModule(MODULE3_NAME, null);
 146
 147         mockModuleImport(module20, moduleConfig);
 148         mockModuleImport(module2, moduleConfig);
 149         mockModuleImport(module3, module20, moduleConfig);
 150         mockModuleImport(module30, module20, moduleConfig);
 151
 152         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
 153
 154         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
 155                 moduleConfig);
 156
 157         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
 158     }
 159
 160     /*
 161      * CFG(R)   ROOT(R)
 162      *  |         \
 163      *  |          \
 164      * M2          M3
 165      */
 166     @Test
 167     public void testBasicMoreRootModules() {
 168         final Module moduleConfig = mockModule(CONFIG_NAME);
 169         final Module moduleRoot = mockModule(ROOT_NAME);
 170         final Module module2 = mockModule(MODULE2_NAME);
 171         final Module module3 = mockModule(MODULE3_NAME);
 172
 173         mockModuleImport(module2, moduleConfig);
 174         mockModuleImport(module3, moduleRoot);
 175
 176         SchemaContext schemaContext = mockSchema(moduleConfig, moduleRoot, module2, module3);
 177
 178         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleRoot,
 179                 moduleConfig);
 180         assertProxyContext(filteringSchemaContextProxy, moduleRoot, module3, moduleConfig, module2);
 181     }
 182
 183     /*
 184      * CFG(R)
 185      *  |
 186      *  |
 187      * M2 <- M3
 188      */
 189     @Test
 190     public void testChainNotDepend() {
 191         Module moduleConfig = mockModule(CONFIG_NAME);
 192         Module module2 = mockModule(MODULE2_NAME);
 193         Module module3 = mockModule(MODULE3_NAME);
 194
 195         mockModuleImport(module2, moduleConfig);
 196         mockModuleImport(module3, module2);
 197
 198         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
 199
 200         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
 201                 moduleConfig);
 202         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2);
 203     }
 204
 205     /*
 206      * CFG(R)
 207      *  |
 208      *  |
 209      * M2 -> M3 -> M4 -> M5
 210      */
 211     @Test
 212     public void testChainDependMulti() {
 213         Module moduleConfig = mockModule(CONFIG_NAME);
 214         Module module2 = mockModule(MODULE2_NAME);
 215         Module module3 = mockModule(MODULE3_NAME);
 216         Module module4 = mockModule(MODULE4_NAME);
 217         Module module5 = mockModule(MODULE5_NAME);
 218
 219         mockModuleImport(module2, moduleConfig, module3);
 220         mockModuleImport(module3, module4);
 221         mockModuleImport(module4, module5);
 222
 223         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4, module5);
 224
 225         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
 226                 moduleConfig);
 227         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4, module5);
 228     }
 229
 230     /*
 231      * CFG(R)
 232      *  |
 233      *  |
 234      * M2 -> M3 <- M4
 235      */
 236     @Test
 237     public void testChainNotDependMulti() {
 238         Module moduleConfig = mockModule(CONFIG_NAME);
 239         Module module2 = mockModule(MODULE2_NAME);
 240         Module module3 = mockModule(MODULE3_NAME);
 241         Module module4 = mockModule(MODULE4_NAME);
 242
 243         mockModuleImport(module2, moduleConfig, module3);
 244         mockModuleImport(module4, module3);
 245
 246         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4);
 247
 248         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
 249                 moduleConfig);
 250         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
 251     }
 252
 253     /*
 254      *  CFG(R)
 255      *  | \ \ \
 256      *  |  \ \ \
 257      * M2 M3 M4 M5
 258      */
 259     @Test
 260     public void testChainNotMulti() {
 261         final Module moduleConfig = mockModule(CONFIG_NAME);
 262         final Module module2 = mockModule(MODULE2_NAME);
 263         final Module module3 = mockModule(MODULE3_NAME);
 264         final Module module4 = mockModule(MODULE4_NAME);
 265         final Module module5 = mockModule(MODULE5_NAME);
 266
 267         mockModuleImport(module2, moduleConfig);
 268         mockModuleImport(module3, moduleConfig);
 269         mockModuleImport(module4, moduleConfig);
 270         mockModuleImport(module5, moduleConfig);
 271
 272         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4, module5);
 273
 274         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
 275                 moduleConfig);
 276         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4, module5);
 277     }
 278
 279     /*
 280      * CFG(R)
 281      *  | \
 282      *  |  \
 283      * M2 <- M3 M4=M3(Different revision)
 284      */
 285     @Test
 286     public void testBasicRevisionChange() throws Exception {
 287         Module moduleConfig = mockModule(CONFIG_NAME);
 288         Module module2 = mockModule(MODULE2_NAME);
 289         Module module3 = mockModule(MODULE3_NAME);
 290         Module module4 = mockModule(MODULE3_NAME, Revision.of("2015-10-10"));
 291
 292         mockModuleImport(module2, moduleConfig);
 293         mockModuleImport(module3, module2, moduleConfig);
 294
 295         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4);
 296
 297         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
 298                 moduleConfig);
 299         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
 300     }
 301
 302     /*
 303      * CFG(R)
 304      * |
 305      * M2 -(no revision)-> M3(R2) ... M3(R1)
 306      */
 307     @Test
 308     public void testImportNoRevision() {
 309         Module moduleConfig = mockModule(CONFIG_NAME, REVISION);
 310         Module module2 = mockModule(MODULE2_NAME, REVISION);
 311
 312         Module module3  = mockModule(MODULE3_NAME, null);
 313         Module module30 = mockModule(MODULE3_NAME, REVISION);
 314         Module module31 = mockModule(MODULE3_NAME, REVISION2);
 315         mockModuleImport(module2, moduleConfig, module3);
 316
 317         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module30, module31);
 318
 319         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
 320                 moduleConfig);
 321
 322         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module31);
 323     }
 324
 325     /*
 326      * CFG(R)
 327      * |   \
 328      * |    \
 329      * |    M2 -> M3
 330      * |
 331      * M41(S) => M4
 332      */
 333     @Test
 334     public void testBasicSubmodule() {
 335         Module moduleConfig = mockModule(CONFIG_NAME);
 336         Module module2 = mockModule(MODULE2_NAME);
 337         Module module3 = mockModule(MODULE3_NAME);
 338         Module module4 = mockModule(MODULE4_NAME);
 339         Module module41 = mockModule(MODULE41_NAME);
 340
 341         mockSubmodules(module4, module41);
 342         mockModuleImport(module2, moduleConfig, module3);
 343         mockModuleImport(module41, moduleConfig);
 344
 345         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4);
 346
 347         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
 348                 moduleConfig);
 349         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4);
 350     }
 351
 352     /*
 353      * M2 -> M3 -> M4 -> M5
 354      */
 355     @Test
 356     public void testChainAdditionalModules() {
 357         Module module2 = mockModule(MODULE2_NAME);
 358         Module module3 = mockModule(MODULE3_NAME);
 359         Module module4 = mockModule(MODULE4_NAME);
 360         Module module5 = mockModule(MODULE5_NAME);
 361
 362         mockModuleImport(module2, module3);
 363         mockModuleImport(module3, module4);
 364         mockModuleImport(module4, module5);
 365
 366         SchemaContext schemaContext = mockSchema(module2, module3, module4, module5);
 367
 368         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
 369                 Collections.singleton(module2), null);
 370         assertProxyContext(filteringSchemaContextProxy, module2, module3, module4, module5);
 371     }
 372
 373     /*
 374      *
 375      * CFG(R)
 376      *  |
 377      *  |       M5
 378      * M2
 379      *
 380      * M3 -> M4
 381      */
 382     @Test
 383     public void testChainAdditionalModulesConfig() {
 384         Module moduleConfig = mockModule(CONFIG_NAME);
 385         Module module2 = mockModule(MODULE2_NAME);
 386
 387         Module module3 = mockModule(MODULE3_NAME);
 388         Module module4 = mockModule(MODULE4_NAME);
 389         Module module5 = mockModule(MODULE5_NAME);
 390
 391         mockModuleImport(module2, moduleConfig);
 392         mockModuleImport(module3, module4);
 393
 394         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4, module5);
 395
 396         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
 397             Collections.singleton(module3), moduleConfig);
 398         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4);
 399     }
 400
 401     @Test
 402     public void testGetDataDefinitions() {
 403         final Module moduleConfig = mockModule(CONFIG_NAME);
 404         final SchemaContext schemaContext = mockSchema(moduleConfig);
 405         final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
 406                 new HashSet<>(), moduleConfig);
 407
 408         final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class);
 409         final Set<DataSchemaNode> childNodes = Collections.singleton(mockedContainer);
 410         doReturn(childNodes).when(moduleConfig).getChildNodes();
 411
 412         final Collection<? extends DataSchemaNode> dataDefinitions =
 413                 filteringSchemaContextProxy.getDataDefinitions();
 414         assertTrue(dataDefinitions.contains(mockedContainer));
 415     }
 416
 417     @Test
 418     public void testGetNotifications() {
 419         final Module moduleConfig = mockModule(CONFIG_NAME);
 420         final SchemaContext schemaContext = mockSchema(moduleConfig);
 421         final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
 422                 new HashSet<>(), moduleConfig);
 423
 424         final NotificationDefinition mockedNotification = mock(NotificationDefinition.class);
 425         final Set<NotificationDefinition> notifications = Collections.singleton(mockedNotification);
 426         doReturn(notifications).when(moduleConfig).getNotifications();
 427
 428         final Collection<? extends NotificationDefinition> schemaContextProxyNotifications =
 429             filteringSchemaContextProxy.getNotifications();
 430         assertTrue(schemaContextProxyNotifications.contains(mockedNotification));
 431     }
 432
 433     @Test
 434     public void testGetOperations() {
 435         final Module moduleConfig = mockModule(CONFIG_NAME);
 436         final SchemaContext schemaContext = mockSchema(moduleConfig);
 437         final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
 438                 new HashSet<>(), moduleConfig);
 439
 440         final RpcDefinition mockedRpc = mock(RpcDefinition.class);
 441         final Set<RpcDefinition> rpcs = Collections.singleton(mockedRpc);
 442         doReturn(rpcs).when(moduleConfig).getRpcs();
 443
 444         final Collection<? extends RpcDefinition> operations = filteringSchemaContextProxy.getOperations();
 445         assertTrue(operations.contains(mockedRpc));
 446     }
 447
 448     @Test
 449     public void testGetExtensions() {
 450         final Module moduleConfig = mockModule(CONFIG_NAME);
 451         final SchemaContext schemaContext = mockSchema(moduleConfig);
 452         final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
 453                 new HashSet<>(), moduleConfig);
 454
 455         final ExtensionDefinition mockedExtension = mock(ExtensionDefinition.class);
 456         final List<ExtensionDefinition> extensions = Collections.singletonList(mockedExtension);
 457         doReturn(extensions).when(moduleConfig).getExtensionSchemaNodes();
 458
 459         final Collection<? extends ExtensionDefinition> schemaContextProxyExtensions =
 460                 filteringSchemaContextProxy.getExtensions();
 461         assertTrue(schemaContextProxyExtensions.contains(mockedExtension));
 462     }
 463
 464     @Test
 465     public void testGetUnknownSchemaNodes() {
 466         final Module moduleConfig = mockModule(CONFIG_NAME);
 467         final SchemaContext schemaContext = mockSchema(moduleConfig);
 468         final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
 469                 new HashSet<>(), moduleConfig);
 470
 471         final UnknownSchemaNode mockedUnknownSchemaNode = mock(UnknownSchemaNode.class);
 472         final List<UnknownSchemaNode> unknownSchemaNodes = Collections.singletonList(mockedUnknownSchemaNode);
 473         doReturn(unknownSchemaNodes).when(moduleConfig).getUnknownSchemaNodes();
 474
 475         final Collection<? extends UnknownSchemaNode> schemaContextProxyUnknownSchemaNodes =
 476                 filteringSchemaContextProxy.getUnknownSchemaNodes();
 477         assertTrue(schemaContextProxyUnknownSchemaNodes.contains(mockedUnknownSchemaNode));
 478     }
 479
 480     @Test
 481     public void testGetTypeDefinitions() {
 482         final Module moduleConfig = mockModule(CONFIG_NAME);
 483         final SchemaContext schemaContext = mockSchema(moduleConfig);
 484         final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
 485                 new HashSet<>(), moduleConfig);
 486
 487         final TypeDefinition<?> mockedTypeDefinition = mock(TypeDefinition.class);
 488         final Set<TypeDefinition<?>> typeDefinitions = Collections.singleton(mockedTypeDefinition);
 489         doReturn(typeDefinitions).when(moduleConfig).getTypeDefinitions();
 490
 491         final Collection<? extends TypeDefinition<?>> schemaContextProxyTypeDefinitions = filteringSchemaContextProxy
 492             .getTypeDefinitions();
 493         assertTrue(schemaContextProxyTypeDefinitions.contains(mockedTypeDefinition));
 494     }
 495
 496     @Test
 497     public void testGetChildNodes() {
 498         final Module moduleConfig = mockModule(CONFIG_NAME);
 499         final SchemaContext schemaContext = mockSchema(moduleConfig);
 500         final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
 501                 new HashSet<>(), moduleConfig);
 502
 503         final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class);
 504         final Set<DataSchemaNode> childNodes = Collections.singleton(mockedContainer);
 505         doReturn(childNodes).when(moduleConfig).getChildNodes();
 506
 507         final Collection<? extends DataSchemaNode> schemaContextProxyChildNodes =
 508                 filteringSchemaContextProxy.getChildNodes();
 509         assertTrue(schemaContextProxyChildNodes.contains(mockedContainer));
 510     }
 511
 512     @Test
 513     public void testGetGroupings() {
 514         final Module moduleConfig = mockModule(CONFIG_NAME);
 515         final SchemaContext schemaContext = mockSchema(moduleConfig);
 516         final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
 517                 new HashSet<>(), moduleConfig);
 518
 519         final GroupingDefinition mockedGrouping = mock(GroupingDefinition.class);
 520         final Set<GroupingDefinition> groupings = Collections.singleton(mockedGrouping);
 521         doReturn(groupings).when(moduleConfig).getGroupings();
 522
 523         final Collection<? extends GroupingDefinition> schemaContextProxyGroupings =
 524                 filteringSchemaContextProxy.getGroupings();
 525         assertTrue(schemaContextProxyGroupings.contains(mockedGrouping));
 526     }
 527
 528     @Test
 529     public void testGetDataChildByName() {
 530         final Module moduleConfig = mockModule(CONFIG_NAME);
 531         final SchemaContext schemaContext = mockSchema(moduleConfig);
 532         final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
 533                 new HashSet<>(), moduleConfig);
 534
 535         final QName qname = QName.create("config-namespace", "2016-08-11", "cont");
 536         final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class);
 537         doReturn(Optional.of(mockedContainer)).when(moduleConfig).findDataChildByName(any(QName.class));
 538
 539         final DataSchemaNode dataSchemaNode = filteringSchemaContextProxy.getDataChildByName(qname);
 540         assertTrue(dataSchemaNode instanceof ContainerSchemaNode);
 541     }
 542
 543     private static void assertProxyContext(final FilteringSchemaContextProxy filteringSchemaContextProxy,
 544             final Module... expected) {
 545
 546         final Set<Module> modSet = expected != null ? ImmutableSet.copyOf(expected) : new HashSet<>();
 547         Set<Module> modSetFiltering = filteringSchemaContextProxy.getModules();
 548
 549         assertEquals(modSet, modSetFiltering);
 550
 551         //asserting collections
 552         if (expected != null) {
 553             for (final Module module : expected) {
 554                 assertEquals(module, filteringSchemaContextProxy.findModule(module.getName(), module.getRevision())
 555                     .get());
 556
 557                 Collection<? extends Module> mod = filteringSchemaContextProxy.findModules(module.getNamespace());
 558                 assertTrue(mod.contains(module));
 559                 assertEquals(module, filteringSchemaContextProxy.findModule(module.getNamespace(),
 560                     module.getRevision().orElse(null)).get());
 561             }
 562         }
 563     }
 564
 565     private static FilteringSchemaContextProxy createProxySchemaCtx(final SchemaContext schemaContext,
 566             final Set<Module> additionalModules, final Module... modules) {
 567         Set<Module> modulesSet = new HashSet<>();
 568         if (modules != null) {
 569             modulesSet = ImmutableSet.copyOf(modules);
 570         }
 571
 572         return new FilteringSchemaContextProxy(schemaContext, createModuleIds(modulesSet),
 573                 createModuleIds(additionalModules));
 574     }
 575
 576     private static Set<ModuleId> createModuleIds(final Set<Module> modules) {
 577         Set<ModuleId> moduleIds = new HashSet<>();
 578         if (modules != null) {
 579             for (Module module : modules) {
 580                 moduleIds.add(new ModuleId(module.getName(), module.getRevision()));
 581             }
 582         }
 583
 584         return moduleIds;
 585     }
 586
 587     private static void mockSubmodules(final Module mainModule, final Module... submodules) {
 588         Set<Module> submodulesSet = new HashSet<>();
 589         submodulesSet.addAll(Arrays.asList(submodules));
 590
 591         doReturn(submodulesSet).when(mainModule).getSubmodules();
 592     }
 593
 594     private static void mockModuleImport(final Module importer, final Module... imports) {
 595         Set<ModuleImport> mockedImports = new HashSet<>();
 596         for (final Module module : imports) {
 597             mockedImports.add(new ModuleImport() {
 598                 @Override
 599                 public String getModuleName() {
 600                     return module.getName();
 601                 }
 602
 603                 @Override
 604                 public Optional<Revision> getRevision() {
 605                     return module.getRevision();
 606                 }
 607
 608                 @Override
 609                 public String getPrefix() {
 610                     return module.getName();
 611                 }
 612
 613                 @Override
 614                 public Optional<SemVer> getSemanticVersion() {
 615                     return module.getSemanticVersion();
 616                 }
 617
 618                 @Override
 619                 public Optional<String> getDescription() {
 620                     return module.getDescription();
 621                 }
 622
 623                 @Override
 624                 public Optional<String> getReference() {
 625                     return module.getReference();
 626                 }
 627
 628                 @Override
 629                 public String toString() {
 630                     return String.format("Module: %s, revision:%s", module.getName(), module.getRevision());
 631                 }
 632
 633                 @Override
 634                 public ImportEffectiveStatement asEffectiveStatement() {
 635                     throw new UnsupportedOperationException();
 636                 }
 637             });
 638         }
 639         doReturn(mockedImports).when(importer).getImports();
 640     }
 641
 642     //mock module with revision
 643     private static Module mockModule(final String name, final Revision rev) {
 644
 645         final Module mod = mockModule(name);
 646
 647         doReturn(QNameModule.create(mod.getNamespace(), rev)).when(mod).getQNameModule();
 648         doReturn(Optional.ofNullable(rev)).when(mod).getRevision();
 649         doReturn(mod.getQNameModule().toString()).when(mod).toString();
 650
 651         return mod;
 652     }
 653
 654     //mock module with default revision
 655     private static Module mockModule(final String name) {
 656
 657         Module mockedModule = mock(Module.class);
 658         doReturn(name).when(mockedModule).getName();
 659         doReturn(Optional.of(REVISION)).when(mockedModule).getRevision();
 660         final URI newNamespace = URI.create(NAMESPACE.toString() + ":" + name);
 661         doReturn(newNamespace).when(mockedModule).getNamespace();
 662         doReturn(QNameModule.create(newNamespace, REVISION)).when(mockedModule).getQNameModule();
 663         doReturn(new HashSet<>()).when(mockedModule).getSubmodules();
 664         doReturn(mockedModule.getQNameModule().toString()).when(mockedModule).toString();
 665         mockModuleImport(mockedModule);
 666
 667         return mockedModule;
 668     }
 669 }