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.Matchers.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.Collections;
  20 import java.util.HashSet;
  21 import java.util.List;
  22 import java.util.Optional;
  23 import java.util.Set;
  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;
  41
  42 public class SchemaContextProxyTest {
  43
  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");
  47
  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";
  55
  56     private static SchemaContext mockSchema(final Module... module) {
  57         SchemaContext mock = mock(SchemaContext.class);
  58         doReturn(ImmutableSet.copyOf(module)).when(mock).getModules();
  59         return mock;
  60     }
  61
  62     /*
  63      * CFG(R)
  64      *  | \
  65      *  |  \
  66      * M2 <- M3
  67      */
  68     @Test
  69     public void testBasic() {
  70         Module moduleConfig = mockModule(CONFIG_NAME);
  71         Module module2 = mockModule(MODULE2_NAME);
  72         Module module3 = mockModule(MODULE3_NAME);
  73
  74         mockModuleImport(module2, moduleConfig);
  75         mockModuleImport(module3, module2, moduleConfig);
  76
  77         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
  78
  79         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
  80                 moduleConfig);
  81         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
  82     }
  83
  84     /*
  85      * No root or additional modules
  86      *  | \
  87      *  |  \
  88      * M2 <- M3
  89      */
  90     @Test
  91     public void testNull() {
  92         Module moduleConfig = mockModule(CONFIG_NAME);
  93         Module module2 = mockModule(MODULE2_NAME);
  94         Module module3 = mockModule(MODULE3_NAME);
  95
  96         mockModuleImport(module2, moduleConfig);
  97         mockModuleImport(module3, module2, moduleConfig);
  98
  99         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
 100
 101         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, null);
 102         assertProxyContext(filteringSchemaContextProxy, null);
 103     }
 104
 105     /*
 106      *  Config
 107      *  | \ (NR)
 108      *  |  \
 109      * M2 <- M3
 110      */
 111     @Test
 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);
 118
 119         mockModuleImport(module2, moduleConfig);
 120         mockModuleImport(module3, module2, moduleConfigNullRevision);
 121
 122         SchemaContext schemaContext = mockSchema(moduleConfig, moduleConfig2, module2, module3);
 123
 124         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
 125                 moduleConfig);
 126         assertProxyContext(filteringSchemaContextProxy, moduleConfig, moduleConfig2, module2, module3);
 127     }
 128
 129     /*
 130      *     CFG(R)
 131      *    |      \
 132      *   |         \
 133      * M2<-(NullRev)M3
 134      */
 135     @Test
 136     public void testBasicNullRevision() throws Exception {
 137         final Module moduleConfig = mockModule(CONFIG_NAME, Revision.of("2013-04-05"));
 138         final Module module2 = mockModule(MODULE2_NAME, Revision.of("2014-06-17"));
 139         final Module module20 = mockModule(MODULE2_NAME, null);
 140         final Module module3 = mockModule(MODULE3_NAME, Revision.of("2014-06-12"));
 141         final Module module30 = mockModule(MODULE3_NAME, null);
 142
 143         mockModuleImport(module20, moduleConfig);
 144         mockModuleImport(module2, moduleConfig);
 145         mockModuleImport(module3, module20, moduleConfig);
 146         mockModuleImport(module30, module20, moduleConfig);
 147
 148         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
 149
 150         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
 151                 moduleConfig);
 152
 153         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
 154     }
 155
 156     /*
 157      * CFG(R)   ROOT(R)
 158      *  |         \
 159      *  |          \
 160      * M2          M3
 161      */
 162     @Test
 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);
 168
 169         mockModuleImport(module2, moduleConfig);
 170         mockModuleImport(module3, moduleRoot);
 171
 172         SchemaContext schemaContext = mockSchema(moduleConfig, moduleRoot, module2, module3);
 173
 174         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleRoot,
 175                 moduleConfig);
 176         assertProxyContext(filteringSchemaContextProxy, moduleRoot, module3, moduleConfig, module2);
 177     }
 178
 179     /*
 180      * CFG(R)
 181      *  |
 182      *  |
 183      * M2 <- M3
 184      */
 185     @Test
 186     public void testChainNotDepend() {
 187         Module moduleConfig = mockModule(CONFIG_NAME);
 188         Module module2 = mockModule(MODULE2_NAME);
 189         Module module3 = mockModule(MODULE3_NAME);
 190
 191         mockModuleImport(module2, moduleConfig);
 192         mockModuleImport(module3, module2);
 193
 194         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
 195
 196         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
 197                 moduleConfig);
 198         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2);
 199     }
 200
 201     /*
 202      * CFG(R)
 203      *  |
 204      *  |
 205      * M2 -> M3 -> M4 -> M5
 206      */
 207     @Test
 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);
 214
 215         mockModuleImport(module2, moduleConfig, module3);
 216         mockModuleImport(module3, module4);
 217         mockModuleImport(module4, module5);
 218
 219         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4, module5);
 220
 221         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
 222                 moduleConfig);
 223         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4, module5);
 224     }
 225
 226     /*
 227      * CFG(R)
 228      *  |
 229      *  |
 230      * M2 -> M3 <- M4
 231      */
 232     @Test
 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);
 238
 239         mockModuleImport(module2, moduleConfig, module3);
 240         mockModuleImport(module4, module3);
 241
 242         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4);
 243
 244         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
 245                 moduleConfig);
 246         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
 247     }
 248
 249     /*
 250      *  CFG(R)
 251      *  | \ \ \
 252      *  |  \ \ \
 253      * M2 M3 M4 M5
 254      */
 255     @Test
 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);
 262
 263         mockModuleImport(module2, moduleConfig);
 264         mockModuleImport(module3, moduleConfig);
 265         mockModuleImport(module4, moduleConfig);
 266         mockModuleImport(module5, moduleConfig);
 267
 268         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4, module5);
 269
 270         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
 271                 moduleConfig);
 272         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4, module5);
 273     }
 274
 275     /*
 276      * CFG(R)
 277      *  | \
 278      *  |  \
 279      * M2 <- M3 M4=M3(Different revision)
 280      */
 281     @Test
 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.of("2015-10-10"));
 287
 288         mockModuleImport(module2, moduleConfig);
 289         mockModuleImport(module3, module2, moduleConfig);
 290
 291         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4);
 292
 293         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
 294                 moduleConfig);
 295         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
 296     }
 297
 298     /*
 299      * CFG(R)
 300      * |
 301      * M2 -(no revision)-> M3(R2) ... M3(R1)
 302      */
 303     @Test
 304     public void testImportNoRevision() {
 305         Module moduleConfig = mockModule(CONFIG_NAME, REVISION);
 306         Module module2 = mockModule(MODULE2_NAME, REVISION);
 307
 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);
 312
 313         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module30, module31);
 314
 315         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
 316                 moduleConfig);
 317
 318         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module31);
 319     }
 320
 321     /*
 322      * CFG(R)
 323      * |   \
 324      * |    \
 325      * |    M2 -> M3
 326      * |
 327      * M41(S) => M4
 328      */
 329     @Test
 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);
 336
 337         mockSubmodules(module4, module41);
 338         mockModuleImport(module2, moduleConfig, module3);
 339         mockModuleImport(module41, moduleConfig);
 340
 341         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4);
 342
 343         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
 344                 moduleConfig);
 345         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4);
 346     }
 347
 348     /*
 349      * M2 -> M3 -> M4 -> M5
 350      */
 351     @Test
 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);
 357
 358         mockModuleImport(module2, module3);
 359         mockModuleImport(module3, module4);
 360         mockModuleImport(module4, module5);
 361
 362         SchemaContext schemaContext = mockSchema(module2, module3, module4, module5);
 363
 364         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
 365                 Collections.singleton(module2), null);
 366         assertProxyContext(filteringSchemaContextProxy, module2, module3, module4, module5);
 367     }
 368
 369     /*
 370      *
 371      * CFG(R)
 372      *  |
 373      *  |       M5
 374      * M2
 375      *
 376      * M3 -> M4
 377      */
 378     @Test
 379     public void testChainAdditionalModulesConfig() {
 380         Module moduleConfig = mockModule(CONFIG_NAME);
 381         Module module2 = mockModule(MODULE2_NAME);
 382
 383         Module module3 = mockModule(MODULE3_NAME);
 384         Module module4 = mockModule(MODULE4_NAME);
 385         Module module5 = mockModule(MODULE5_NAME);
 386
 387         mockModuleImport(module2, moduleConfig);
 388         mockModuleImport(module3, module4);
 389
 390         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4, module5);
 391
 392         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
 393             Collections.singleton(module3), moduleConfig);
 394         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4);
 395     }
 396
 397     @Test
 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);
 403
 404         final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class);
 405         final Set<DataSchemaNode> childNodes = Collections.singleton(mockedContainer);
 406         doReturn(childNodes).when(moduleConfig).getChildNodes();
 407
 408         final Set<DataSchemaNode> dataDefinitions = filteringSchemaContextProxy.getDataDefinitions();
 409         assertTrue(dataDefinitions.contains(mockedContainer));
 410     }
 411
 412     @Test
 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);
 418
 419         final NotificationDefinition mockedNotification = mock(NotificationDefinition.class);
 420         final Set<NotificationDefinition> notifications = Collections.singleton(mockedNotification);
 421         doReturn(notifications).when(moduleConfig).getNotifications();
 422
 423         final Set<NotificationDefinition> schemaContextProxyNotifications =
 424             filteringSchemaContextProxy.getNotifications();
 425         assertTrue(schemaContextProxyNotifications.contains(mockedNotification));
 426     }
 427
 428     @Test
 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);
 434
 435         final RpcDefinition mockedRpc = mock(RpcDefinition.class);
 436         final Set<RpcDefinition> rpcs = Collections.singleton(mockedRpc);
 437         doReturn(rpcs).when(moduleConfig).getRpcs();
 438
 439         final Set<RpcDefinition> operations = filteringSchemaContextProxy.getOperations();
 440         assertTrue(operations.contains(mockedRpc));
 441     }
 442
 443     @Test
 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);
 449
 450         final ExtensionDefinition mockedExtension = mock(ExtensionDefinition.class);
 451         final List<ExtensionDefinition> extensions = Collections.singletonList(mockedExtension);
 452         doReturn(extensions).when(moduleConfig).getExtensionSchemaNodes();
 453
 454         final Set<ExtensionDefinition> schemaContextProxyExtensions = filteringSchemaContextProxy.getExtensions();
 455         assertTrue(schemaContextProxyExtensions.contains(mockedExtension));
 456     }
 457
 458     @Test
 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);
 464
 465         final UnknownSchemaNode mockedUnknownSchemaNode = mock(UnknownSchemaNode.class);
 466         final List<UnknownSchemaNode> unknownSchemaNodes = Collections.singletonList(mockedUnknownSchemaNode);
 467         doReturn(unknownSchemaNodes).when(moduleConfig).getUnknownSchemaNodes();
 468
 469         final List<UnknownSchemaNode> schemaContextProxyUnknownSchemaNodes =
 470                 filteringSchemaContextProxy.getUnknownSchemaNodes();
 471         assertTrue(schemaContextProxyUnknownSchemaNodes.contains(mockedUnknownSchemaNode));
 472     }
 473
 474     @Test
 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);
 480
 481         final TypeDefinition<?> mockedTypeDefinition = mock(TypeDefinition.class);
 482         final Set<TypeDefinition<?>> typeDefinitions = Collections.singleton(mockedTypeDefinition);
 483         doReturn(typeDefinitions).when(moduleConfig).getTypeDefinitions();
 484
 485         final Set<TypeDefinition<?>> schemaContextProxyTypeDefinitions = filteringSchemaContextProxy
 486             .getTypeDefinitions();
 487         assertTrue(schemaContextProxyTypeDefinitions.contains(mockedTypeDefinition));
 488     }
 489
 490     @Test
 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);
 496
 497         final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class);
 498         final Set<DataSchemaNode> childNodes = Collections.singleton(mockedContainer);
 499         doReturn(childNodes).when(moduleConfig).getChildNodes();
 500
 501         final Set<DataSchemaNode> schemaContextProxyChildNodes = filteringSchemaContextProxy.getChildNodes();
 502         assertTrue(schemaContextProxyChildNodes.contains(mockedContainer));
 503     }
 504
 505     @Test
 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);
 511
 512         final GroupingDefinition mockedGrouping = mock(GroupingDefinition.class);
 513         final Set<GroupingDefinition> groupings = Collections.singleton(mockedGrouping);
 514         doReturn(groupings).when(moduleConfig).getGroupings();
 515
 516         final Set<GroupingDefinition> schemaContextProxyGroupings = filteringSchemaContextProxy.getGroupings();
 517         assertTrue(schemaContextProxyGroupings.contains(mockedGrouping));
 518     }
 519
 520     @Test
 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);
 526
 527         final QName qname = QName.create("config-namespace", "2016-08-11", "cont");
 528         final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class);
 529         doReturn(Optional.of(mockedContainer)).when(moduleConfig).findDataChildByName(any(QName.class));
 530
 531         final DataSchemaNode dataSchemaNode = filteringSchemaContextProxy.getDataChildByName(qname);
 532         assertTrue(dataSchemaNode instanceof ContainerSchemaNode);
 533     }
 534
 535     private static void assertProxyContext(final FilteringSchemaContextProxy filteringSchemaContextProxy,
 536             final Module... expected) {
 537
 538         final Set<Module> modSet = expected != null ? ImmutableSet.copyOf(expected) : new HashSet<>();
 539         Set<Module> modSetFiltering = filteringSchemaContextProxy.getModules();
 540
 541         assertEquals(modSet, modSetFiltering);
 542
 543         //asserting collections
 544         if (expected != null) {
 545             for (final Module module : expected) {
 546                 assertEquals(module, filteringSchemaContextProxy.findModule(module.getName(), module.getRevision())
 547                     .get());
 548
 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());
 553             }
 554         }
 555     }
 556
 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);
 562         }
 563
 564         return new FilteringSchemaContextProxy(schemaContext, createModuleIds(modulesSet),
 565                 createModuleIds(additionalModules));
 566     }
 567
 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()));
 573             }
 574         }
 575
 576         return moduleIds;
 577     }
 578
 579     private static void mockSubmodules(final Module mainModule, final Module... submodules) {
 580         Set<Module> submodulesSet = new HashSet<>();
 581         submodulesSet.addAll(Arrays.asList(submodules));
 582
 583         doReturn(submodulesSet).when(mainModule).getSubmodules();
 584     }
 585
 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() {
 590                 @Override
 591                 public String getModuleName() {
 592                     return module.getName();
 593                 }
 594
 595                 @Override
 596                 public Optional<Revision> getRevision() {
 597                     return module.getRevision();
 598                 }
 599
 600                 @Override
 601                 public String getPrefix() {
 602                     return module.getName();
 603                 }
 604
 605                 @Override
 606                 public Optional<SemVer> getSemanticVersion() {
 607                     return module.getSemanticVersion();
 608                 }
 609
 610                 @Override
 611                 public Optional<String> getDescription() {
 612                     return module.getDescription();
 613                 }
 614
 615                 @Override
 616                 public Optional<String> getReference() {
 617                     return module.getReference();
 618                 }
 619
 620                 @Override
 621                 public String toString() {
 622                     return String.format("Module: %s, revision:%s", module.getName(), module.getRevision());
 623                 }
 624             });
 625         }
 626         doReturn(mockedImports).when(importer).getImports();
 627     }
 628
 629     //mock module with revision
 630     private static Module mockModule(final String name, final Revision rev) {
 631
 632         final Module mod = mockModule(name);
 633
 634         doReturn(QNameModule.create(mod.getNamespace(), rev)).when(mod).getQNameModule();
 635         doReturn(Optional.ofNullable(rev)).when(mod).getRevision();
 636         doReturn(mod.getQNameModule().toString()).when(mod).toString();
 637
 638         return mod;
 639     }
 640
 641     //mock module with default revision
 642     private static Module mockModule(final String name) {
 643
 644         Module mockedModule = mock(Module.class);
 645         doReturn(name).when(mockedModule).getName();
 646         doReturn(Optional.of(REVISION)).when(mockedModule).getRevision();
 647         final URI newNamespace = URI.create(NAMESPACE.toString() + ":" + name);
 648         doReturn(newNamespace).when(mockedModule).getNamespace();
 649         doReturn(QNameModule.create(newNamespace, REVISION)).when(mockedModule).getQNameModule();
 650         doReturn(new HashSet<>()).when(mockedModule).getSubmodules();
 651         doReturn(mockedModule.getQNameModule().toString()).when(mockedModule).toString();
 652         mockModuleImport(mockedModule);
 653
 654         return mockedModule;
 655     }
 656 }