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