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.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... 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();
  61         return mock;
  62     }
  63
  64     /*
  65      * CFG(R)
  66      *  | \
  67      *  |  \
  68      * M2 <- M3
  69      */
  70     @Test
  71     public void testBasic() {
  72         Module moduleConfig = mockModule(CONFIG_NAME);
  73         Module module2 = mockModule(MODULE2_NAME);
  74         Module module3 = mockModule(MODULE3_NAME);
  75
  76         mockModuleImport(module2, moduleConfig);
  77         mockModuleImport(module3, module2, moduleConfig);
  78
  79         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
  80
  81         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
  82                 moduleConfig);
  83         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
  84     }
  85
  86     /*
  87      * No root or additional modules
  88      *  | \
  89      *  |  \
  90      * M2 <- M3
  91      */
  92     @Test
  93     public void testNull() {
  94         Module moduleConfig = mockModule(CONFIG_NAME);
  95         Module module2 = mockModule(MODULE2_NAME);
  96         Module module3 = mockModule(MODULE3_NAME);
  97
  98         mockModuleImport(module2, moduleConfig);
  99         mockModuleImport(module3, module2, moduleConfig);
 100
 101         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
 102
 103         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, null);
 104         assertProxyContext(filteringSchemaContextProxy, null);
 105     }
 106
 107     /*
 108      *  Config
 109      *  | \ (NR)
 110      *  |  \
 111      * M2 <- M3
 112      */
 113     @Test
 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);
 120
 121         mockModuleImport(module2, moduleConfig);
 122         mockModuleImport(module3, module2, moduleConfigNullRevision);
 123
 124         SchemaContext schemaContext = mockSchema(moduleConfig, moduleConfig2, module2, module3);
 125
 126         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
 127                 moduleConfig);
 128         assertProxyContext(filteringSchemaContextProxy, moduleConfig, moduleConfig2, module2, module3);
 129     }
 130
 131     /*
 132      *     CFG(R)
 133      *    |      \
 134      *   |         \
 135      * M2<-(NullRev)M3
 136      */
 137     @Test
 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);
 144
 145         mockModuleImport(module20, moduleConfig);
 146         mockModuleImport(module2, moduleConfig);
 147         mockModuleImport(module3, module20, moduleConfig);
 148         mockModuleImport(module30, module20, moduleConfig);
 149
 150         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
 151
 152         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
 153                 moduleConfig);
 154
 155         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
 156     }
 157
 158     /*
 159      * CFG(R)   ROOT(R)
 160      *  |         \
 161      *  |          \
 162      * M2          M3
 163      */
 164     @Test
 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);
 170
 171         mockModuleImport(module2, moduleConfig);
 172         mockModuleImport(module3, moduleRoot);
 173
 174         SchemaContext schemaContext = mockSchema(moduleConfig, moduleRoot, module2, module3);
 175
 176         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleRoot,
 177                 moduleConfig);
 178         assertProxyContext(filteringSchemaContextProxy, moduleRoot, module3, moduleConfig, module2);
 179     }
 180
 181     /*
 182      * CFG(R)
 183      *  |
 184      *  |
 185      * M2 <- M3
 186      */
 187     @Test
 188     public void testChainNotDepend() {
 189         Module moduleConfig = mockModule(CONFIG_NAME);
 190         Module module2 = mockModule(MODULE2_NAME);
 191         Module module3 = mockModule(MODULE3_NAME);
 192
 193         mockModuleImport(module2, moduleConfig);
 194         mockModuleImport(module3, module2);
 195
 196         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
 197
 198         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
 199                 moduleConfig);
 200         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2);
 201     }
 202
 203     /*
 204      * CFG(R)
 205      *  |
 206      *  |
 207      * M2 -> M3 -> M4 -> M5
 208      */
 209     @Test
 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);
 216
 217         mockModuleImport(module2, moduleConfig, module3);
 218         mockModuleImport(module3, module4);
 219         mockModuleImport(module4, module5);
 220
 221         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4, module5);
 222
 223         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
 224                 moduleConfig);
 225         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4, module5);
 226     }
 227
 228     /*
 229      * CFG(R)
 230      *  |
 231      *  |
 232      * M2 -> M3 <- M4
 233      */
 234     @Test
 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);
 240
 241         mockModuleImport(module2, moduleConfig, module3);
 242         mockModuleImport(module4, module3);
 243
 244         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4);
 245
 246         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
 247                 moduleConfig);
 248         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
 249     }
 250
 251     /*
 252      *  CFG(R)
 253      *  | \ \ \
 254      *  |  \ \ \
 255      * M2 M3 M4 M5
 256      */
 257     @Test
 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);
 264
 265         mockModuleImport(module2, moduleConfig);
 266         mockModuleImport(module3, moduleConfig);
 267         mockModuleImport(module4, moduleConfig);
 268         mockModuleImport(module5, moduleConfig);
 269
 270         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4, module5);
 271
 272         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
 273                 moduleConfig);
 274         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4, module5);
 275     }
 276
 277     /*
 278      * CFG(R)
 279      *  | \
 280      *  |  \
 281      * M2 <- M3 M4=M3(Different revision)
 282      */
 283     @Test
 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"));
 289
 290         mockModuleImport(module2, moduleConfig);
 291         mockModuleImport(module3, module2, moduleConfig);
 292
 293         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4);
 294
 295         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
 296                 moduleConfig);
 297         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
 298     }
 299
 300     /*
 301      * CFG(R)
 302      * |
 303      * M2 -(no revision)-> M3(R2) ... M3(R1)
 304      */
 305     @Test
 306     public void testImportNoRevision() {
 307         Module moduleConfig = mockModule(CONFIG_NAME, REVISION);
 308         Module module2 = mockModule(MODULE2_NAME, REVISION);
 309
 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);
 314
 315         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module30, module31);
 316
 317         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
 318                 moduleConfig);
 319
 320         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module31);
 321     }
 322
 323     /*
 324      * CFG(R)
 325      * |   \
 326      * |    \
 327      * |    M2 -> M3
 328      * |
 329      * M41(S) => M4
 330      */
 331     @Test
 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);
 338
 339         mockSubmodules(module4, module41);
 340         mockModuleImport(module2, moduleConfig, module3);
 341         mockModuleImport(module41, moduleConfig);
 342
 343         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4);
 344
 345         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
 346                 moduleConfig);
 347         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4);
 348     }
 349
 350     /*
 351      * M2 -> M3 -> M4 -> M5
 352      */
 353     @Test
 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);
 359
 360         mockModuleImport(module2, module3);
 361         mockModuleImport(module3, module4);
 362         mockModuleImport(module4, module5);
 363
 364         SchemaContext schemaContext = mockSchema(module2, module3, module4, module5);
 365
 366         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
 367                 Collections.singleton(module2), null);
 368         assertProxyContext(filteringSchemaContextProxy, module2, module3, module4, module5);
 369     }
 370
 371     /*
 372      *
 373      * CFG(R)
 374      *  |
 375      *  |       M5
 376      * M2
 377      *
 378      * M3 -> M4
 379      */
 380     @Test
 381     public void testChainAdditionalModulesConfig() {
 382         Module moduleConfig = mockModule(CONFIG_NAME);
 383         Module module2 = mockModule(MODULE2_NAME);
 384
 385         Module module3 = mockModule(MODULE3_NAME);
 386         Module module4 = mockModule(MODULE4_NAME);
 387         Module module5 = mockModule(MODULE5_NAME);
 388
 389         mockModuleImport(module2, moduleConfig);
 390         mockModuleImport(module3, module4);
 391
 392         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4, module5);
 393
 394         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
 395             Collections.singleton(module3), moduleConfig);
 396         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4);
 397     }
 398
 399     @Test
 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);
 405
 406         final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class);
 407         final Set<DataSchemaNode> childNodes = Collections.singleton(mockedContainer);
 408         doReturn(childNodes).when(moduleConfig).getChildNodes();
 409
 410         final Set<DataSchemaNode> dataDefinitions = filteringSchemaContextProxy.getDataDefinitions();
 411         assertTrue(dataDefinitions.contains(mockedContainer));
 412     }
 413
 414     @Test
 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);
 420
 421         final NotificationDefinition mockedNotification = mock(NotificationDefinition.class);
 422         final Set<NotificationDefinition> notifications = Collections.singleton(mockedNotification);
 423         doReturn(notifications).when(moduleConfig).getNotifications();
 424
 425         final Set<NotificationDefinition> schemaContextProxyNotifications =
 426             filteringSchemaContextProxy.getNotifications();
 427         assertTrue(schemaContextProxyNotifications.contains(mockedNotification));
 428     }
 429
 430     @Test
 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);
 436
 437         final RpcDefinition mockedRpc = mock(RpcDefinition.class);
 438         final Set<RpcDefinition> rpcs = Collections.singleton(mockedRpc);
 439         doReturn(rpcs).when(moduleConfig).getRpcs();
 440
 441         final Set<RpcDefinition> operations = filteringSchemaContextProxy.getOperations();
 442         assertTrue(operations.contains(mockedRpc));
 443     }
 444
 445     @Test
 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);
 451
 452         final ExtensionDefinition mockedExtension = mock(ExtensionDefinition.class);
 453         final List<ExtensionDefinition> extensions = Collections.singletonList(mockedExtension);
 454         doReturn(extensions).when(moduleConfig).getExtensionSchemaNodes();
 455
 456         final Set<ExtensionDefinition> schemaContextProxyExtensions = filteringSchemaContextProxy.getExtensions();
 457         assertTrue(schemaContextProxyExtensions.contains(mockedExtension));
 458     }
 459
 460     @Test
 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);
 466
 467         final UnknownSchemaNode mockedUnknownSchemaNode = mock(UnknownSchemaNode.class);
 468         final List<UnknownSchemaNode> unknownSchemaNodes = Collections.singletonList(mockedUnknownSchemaNode);
 469         doReturn(unknownSchemaNodes).when(moduleConfig).getUnknownSchemaNodes();
 470
 471         final List<UnknownSchemaNode> schemaContextProxyUnknownSchemaNodes =
 472                 filteringSchemaContextProxy.getUnknownSchemaNodes();
 473         assertTrue(schemaContextProxyUnknownSchemaNodes.contains(mockedUnknownSchemaNode));
 474     }
 475
 476     @Test
 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);
 482
 483         final TypeDefinition<?> mockedTypeDefinition = mock(TypeDefinition.class);
 484         final Set<TypeDefinition<?>> typeDefinitions = Collections.singleton(mockedTypeDefinition);
 485         doReturn(typeDefinitions).when(moduleConfig).getTypeDefinitions();
 486
 487         final Set<TypeDefinition<?>> schemaContextProxyTypeDefinitions = filteringSchemaContextProxy
 488             .getTypeDefinitions();
 489         assertTrue(schemaContextProxyTypeDefinitions.contains(mockedTypeDefinition));
 490     }
 491
 492     @Test
 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);
 498
 499         final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class);
 500         final Set<DataSchemaNode> childNodes = Collections.singleton(mockedContainer);
 501         doReturn(childNodes).when(moduleConfig).getChildNodes();
 502
 503         final Set<DataSchemaNode> schemaContextProxyChildNodes = filteringSchemaContextProxy.getChildNodes();
 504         assertTrue(schemaContextProxyChildNodes.contains(mockedContainer));
 505     }
 506
 507     @Test
 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);
 513
 514         final GroupingDefinition mockedGrouping = mock(GroupingDefinition.class);
 515         final Set<GroupingDefinition> groupings = Collections.singleton(mockedGrouping);
 516         doReturn(groupings).when(moduleConfig).getGroupings();
 517
 518         final Set<GroupingDefinition> schemaContextProxyGroupings = filteringSchemaContextProxy.getGroupings();
 519         assertTrue(schemaContextProxyGroupings.contains(mockedGrouping));
 520     }
 521
 522     @Test
 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);
 528
 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));
 532
 533         final DataSchemaNode dataSchemaNode = filteringSchemaContextProxy.getDataChildByName(qname);
 534         assertTrue(dataSchemaNode instanceof ContainerSchemaNode);
 535     }
 536
 537     private static void assertProxyContext(final FilteringSchemaContextProxy filteringSchemaContextProxy,
 538             final Module... expected) {
 539
 540         final Set<Module> modSet = expected != null ? ImmutableSet.copyOf(expected) : new HashSet<>();
 541         Set<Module> modSetFiltering = filteringSchemaContextProxy.getModules();
 542
 543         assertEquals(modSet, modSetFiltering);
 544
 545         //asserting collections
 546         if (expected != null) {
 547             for (final Module module : expected) {
 548                 assertEquals(module, filteringSchemaContextProxy.findModule(module.getName(), module.getRevision())
 549                     .get());
 550
 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());
 555             }
 556         }
 557     }
 558
 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);
 564         }
 565
 566         return new FilteringSchemaContextProxy(schemaContext, createModuleIds(modulesSet),
 567                 createModuleIds(additionalModules));
 568     }
 569
 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()));
 575             }
 576         }
 577
 578         return moduleIds;
 579     }
 580
 581     private static void mockSubmodules(final Module mainModule, final Module... submodules) {
 582         Set<Module> submodulesSet = new HashSet<>();
 583         submodulesSet.addAll(Arrays.asList(submodules));
 584
 585         doReturn(submodulesSet).when(mainModule).getSubmodules();
 586     }
 587
 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() {
 592                 @Override
 593                 public String getModuleName() {
 594                     return module.getName();
 595                 }
 596
 597                 @Override
 598                 public Optional<Revision> getRevision() {
 599                     return module.getRevision();
 600                 }
 601
 602                 @Override
 603                 public String getPrefix() {
 604                     return module.getName();
 605                 }
 606
 607                 @Override
 608                 public Optional<SemVer> getSemanticVersion() {
 609                     return module.getSemanticVersion();
 610                 }
 611
 612                 @Override
 613                 public Optional<String> getDescription() {
 614                     return module.getDescription();
 615                 }
 616
 617                 @Override
 618                 public Optional<String> getReference() {
 619                     return module.getReference();
 620                 }
 621
 622                 @Override
 623                 public String toString() {
 624                     return String.format("Module: %s, revision:%s", module.getName(), module.getRevision());
 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
 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);
 655
 656         return mockedModule;
 657     }
 658 }