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