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