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