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.common.XMLNamespace;
  31 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
  32 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  33 import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
  34 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
  35 import org.opendaylight.yangtools.yang.model.api.Module;
  36 import org.opendaylight.yangtools.yang.model.api.ModuleImport;
  37 import org.opendaylight.yangtools.yang.model.api.ModuleLike;
  38 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
  39 import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
  40 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  41 import org.opendaylight.yangtools.yang.model.api.Submodule;
  42 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
  43 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
  44 import org.opendaylight.yangtools.yang.model.api.stmt.ImportEffectiveStatement;
  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,
 372                 Collections.singleton(module2), 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,
 400             Collections.singleton(module3), 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,
 409                 new HashSet<>(), moduleConfig);
 410
 411         final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class);
 412         final Set<DataSchemaNode> childNodes = Collections.singleton(mockedContainer);
 413         doReturn(childNodes).when(moduleConfig).getChildNodes();
 414
 415         final Collection<? extends DataSchemaNode> dataDefinitions =
 416                 filteringSchemaContextProxy.getDataDefinitions();
 417         assertTrue(dataDefinitions.contains(mockedContainer));
 418     }
 419
 420     @Test
 421     public void testGetNotifications() {
 422         final Module moduleConfig = mockModule(CONFIG_NAME);
 423         final SchemaContext schemaContext = mockSchema(moduleConfig);
 424         final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
 425                 new HashSet<>(), moduleConfig);
 426
 427         final NotificationDefinition mockedNotification = mock(NotificationDefinition.class);
 428         final Set<NotificationDefinition> notifications = Collections.singleton(mockedNotification);
 429         doReturn(notifications).when(moduleConfig).getNotifications();
 430
 431         final Collection<? extends NotificationDefinition> schemaContextProxyNotifications =
 432             filteringSchemaContextProxy.getNotifications();
 433         assertTrue(schemaContextProxyNotifications.contains(mockedNotification));
 434     }
 435
 436     @Test
 437     public void testGetOperations() {
 438         final Module moduleConfig = mockModule(CONFIG_NAME);
 439         final SchemaContext schemaContext = mockSchema(moduleConfig);
 440         final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
 441                 new HashSet<>(), moduleConfig);
 442
 443         final RpcDefinition mockedRpc = mock(RpcDefinition.class);
 444         final Set<RpcDefinition> rpcs = Collections.singleton(mockedRpc);
 445         doReturn(rpcs).when(moduleConfig).getRpcs();
 446
 447         final Collection<? extends RpcDefinition> operations = filteringSchemaContextProxy.getOperations();
 448         assertTrue(operations.contains(mockedRpc));
 449     }
 450
 451     @Test
 452     public void testGetExtensions() {
 453         final Module moduleConfig = mockModule(CONFIG_NAME);
 454         final SchemaContext schemaContext = mockSchema(moduleConfig);
 455         final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
 456                 new HashSet<>(), moduleConfig);
 457
 458         final ExtensionDefinition mockedExtension = mock(ExtensionDefinition.class);
 459         final List<ExtensionDefinition> extensions = Collections.singletonList(mockedExtension);
 460         doReturn(extensions).when(moduleConfig).getExtensionSchemaNodes();
 461
 462         final Collection<? extends ExtensionDefinition> schemaContextProxyExtensions =
 463                 filteringSchemaContextProxy.getExtensions();
 464         assertTrue(schemaContextProxyExtensions.contains(mockedExtension));
 465     }
 466
 467     @Test
 468     public void testGetUnknownSchemaNodes() {
 469         final Module moduleConfig = mockModule(CONFIG_NAME);
 470         final SchemaContext schemaContext = mockSchema(moduleConfig);
 471         final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
 472                 new HashSet<>(), moduleConfig);
 473
 474         final UnknownSchemaNode mockedUnknownSchemaNode = mock(UnknownSchemaNode.class);
 475         final List<UnknownSchemaNode> unknownSchemaNodes = Collections.singletonList(mockedUnknownSchemaNode);
 476         doReturn(unknownSchemaNodes).when(moduleConfig).getUnknownSchemaNodes();
 477
 478         final Collection<? extends UnknownSchemaNode> schemaContextProxyUnknownSchemaNodes =
 479                 filteringSchemaContextProxy.getUnknownSchemaNodes();
 480         assertTrue(schemaContextProxyUnknownSchemaNodes.contains(mockedUnknownSchemaNode));
 481     }
 482
 483     @Test
 484     public void testGetTypeDefinitions() {
 485         final Module moduleConfig = mockModule(CONFIG_NAME);
 486         final SchemaContext schemaContext = mockSchema(moduleConfig);
 487         final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
 488                 new HashSet<>(), moduleConfig);
 489
 490         final TypeDefinition<?> mockedTypeDefinition = mock(TypeDefinition.class);
 491         final Set<TypeDefinition<?>> typeDefinitions = Collections.singleton(mockedTypeDefinition);
 492         doReturn(typeDefinitions).when(moduleConfig).getTypeDefinitions();
 493
 494         final Collection<? extends TypeDefinition<?>> schemaContextProxyTypeDefinitions = filteringSchemaContextProxy
 495             .getTypeDefinitions();
 496         assertTrue(schemaContextProxyTypeDefinitions.contains(mockedTypeDefinition));
 497     }
 498
 499     @Test
 500     public void testGetChildNodes() {
 501         final Module moduleConfig = mockModule(CONFIG_NAME);
 502         final SchemaContext schemaContext = mockSchema(moduleConfig);
 503         final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
 504                 new HashSet<>(), moduleConfig);
 505
 506         final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class);
 507         final Set<DataSchemaNode> childNodes = Collections.singleton(mockedContainer);
 508         doReturn(childNodes).when(moduleConfig).getChildNodes();
 509
 510         final Collection<? extends DataSchemaNode> schemaContextProxyChildNodes =
 511                 filteringSchemaContextProxy.getChildNodes();
 512         assertTrue(schemaContextProxyChildNodes.contains(mockedContainer));
 513     }
 514
 515     @Test
 516     public void testGetGroupings() {
 517         final Module moduleConfig = mockModule(CONFIG_NAME);
 518         final SchemaContext schemaContext = mockSchema(moduleConfig);
 519         final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
 520                 new HashSet<>(), moduleConfig);
 521
 522         final GroupingDefinition mockedGrouping = mock(GroupingDefinition.class);
 523         final Set<GroupingDefinition> groupings = Collections.singleton(mockedGrouping);
 524         doReturn(groupings).when(moduleConfig).getGroupings();
 525
 526         final Collection<? extends GroupingDefinition> schemaContextProxyGroupings =
 527                 filteringSchemaContextProxy.getGroupings();
 528         assertTrue(schemaContextProxyGroupings.contains(mockedGrouping));
 529     }
 530
 531     @Test
 532     public void testGetDataChildByName() {
 533         final Module moduleConfig = mockModule(CONFIG_NAME);
 534         final SchemaContext schemaContext = mockSchema(moduleConfig);
 535         final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
 536                 new HashSet<>(), moduleConfig);
 537
 538         final QName qname = QName.create("config-namespace", "2016-08-11", "cont");
 539         final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class);
 540         doReturn(mockedContainer).when(moduleConfig).dataChildByName(any(QName.class));
 541
 542         final DataSchemaNode dataSchemaNode = filteringSchemaContextProxy.getDataChildByName(qname);
 543         assertTrue(dataSchemaNode instanceof ContainerSchemaNode);
 544     }
 545
 546     private static void assertProxyContext(final FilteringSchemaContextProxy filteringSchemaContextProxy,
 547             final Module... expected) {
 548
 549         final Set<Module> modSet = expected != null ? ImmutableSet.copyOf(expected) : new HashSet<>();
 550         Set<Module> modSetFiltering = filteringSchemaContextProxy.getModules();
 551
 552         assertEquals(modSet, modSetFiltering);
 553
 554         //asserting collections
 555         if (expected != null) {
 556             for (final Module module : expected) {
 557                 assertEquals(module, filteringSchemaContextProxy.findModule(module.getName(), module.getRevision())
 558                     .get());
 559
 560                 Collection<? extends Module> mod = filteringSchemaContextProxy.findModules(module.getNamespace());
 561                 assertTrue(mod.contains(module));
 562                 assertEquals(module, filteringSchemaContextProxy.findModule(module.getNamespace(),
 563                     module.getRevision().orElse(null)).get());
 564             }
 565         }
 566     }
 567
 568     private static FilteringSchemaContextProxy createProxySchemaCtx(final SchemaContext schemaContext,
 569             final Set<Module> additionalModules, final Module... modules) {
 570         Set<Module> modulesSet = new HashSet<>();
 571         if (modules != null) {
 572             modulesSet = ImmutableSet.copyOf(modules);
 573         }
 574
 575         return new FilteringSchemaContextProxy(schemaContext, createModuleIds(modulesSet),
 576                 createModuleIds(additionalModules));
 577     }
 578
 579     private static Set<ModuleId> createModuleIds(final Set<Module> modules) {
 580         Set<ModuleId> moduleIds = new HashSet<>();
 581         if (modules != null) {
 582             for (Module module : modules) {
 583                 moduleIds.add(new ModuleId(module.getName(), module.getRevision()));
 584             }
 585         }
 586
 587         return moduleIds;
 588     }
 589
 590     private static void mockSubmodules(final Module mainModule, final Submodule... submodules) {
 591         Set<Submodule> submodulesSet = new HashSet<>();
 592         submodulesSet.addAll(Arrays.asList(submodules));
 593
 594         doReturn(submodulesSet).when(mainModule).getSubmodules();
 595     }
 596
 597     private static void mockModuleImport(final ModuleLike importer, final Module... imports) {
 598         Set<ModuleImport> mockedImports = new HashSet<>();
 599         for (final Module module : imports) {
 600             mockedImports.add(new ModuleImport() {
 601                 @Override
 602                 public String getModuleName() {
 603                     return module.getName();
 604                 }
 605
 606                 @Override
 607                 public Optional<Revision> getRevision() {
 608                     return module.getRevision();
 609                 }
 610
 611                 @Override
 612                 public String getPrefix() {
 613                     return module.getName();
 614                 }
 615
 616                 @Override
 617                 public Optional<SemVer> getSemanticVersion() {
 618                     return module.getSemanticVersion();
 619                 }
 620
 621                 @Override
 622                 public Optional<String> getDescription() {
 623                     return module.getDescription();
 624                 }
 625
 626                 @Override
 627                 public Optional<String> getReference() {
 628                     return module.getReference();
 629                 }
 630
 631                 @Override
 632                 public String toString() {
 633                     return String.format("Module: %s, revision:%s", module.getName(), module.getRevision());
 634                 }
 635
 636                 @Override
 637                 public ImportEffectiveStatement asEffectiveStatement() {
 638                     throw new UnsupportedOperationException();
 639                 }
 640             });
 641         }
 642         doReturn(mockedImports).when(importer).getImports();
 643     }
 644
 645     //mock module with revision
 646     private static Module mockModule(final String name, final Revision rev) {
 647
 648         final Module mod = mockModule(name);
 649
 650         doReturn(QNameModule.create(mod.getNamespace(), rev)).when(mod).getQNameModule();
 651         doReturn(Optional.ofNullable(rev)).when(mod).getRevision();
 652         doReturn(mod.getQNameModule().toString()).when(mod).toString();
 653
 654         return mod;
 655     }
 656
 657     //mock module with default revision
 658     private static Module mockModule(final String name) {
 659         Module mockedModule = mock(Module.class);
 660         mockModuleLike(mockedModule, name);
 661         return mockedModule;
 662     }
 663
 664     private static Submodule mockSubmodule(final String name) {
 665         Submodule mockedModule = mock(Submodule.class);
 666         mockModuleLike(mockedModule, name);
 667         return mockedModule;
 668     }
 669
 670     private static void mockModuleLike(final ModuleLike mockedModule, final String name) {
 671         doReturn(name).when(mockedModule).getName();
 672         doReturn(Optional.of(REVISION)).when(mockedModule).getRevision();
 673         final XMLNamespace newNamespace = XMLNamespace.of(NAMESPACE.toString() + ":" + name);
 674         doReturn(newNamespace).when(mockedModule).getNamespace();
 675         doReturn(QNameModule.create(newNamespace, REVISION)).when(mockedModule).getQNameModule();
 676         doReturn(new HashSet<>()).when(mockedModule).getSubmodules();
 677         doReturn(mockedModule.getQNameModule().toString()).when(mockedModule).toString();
 678         mockModuleImport(mockedModule);
 679     }
 680 }