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