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