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.Mockito.doReturn;
  13 import static org.mockito.Mockito.mock;
  14
  15 import com.google.common.collect.Sets;
  16 import java.net.URI;
  17 import java.net.URISyntaxException;
  18 import java.text.ParseException;
  19 import java.util.Arrays;
  20 import java.util.Date;
  21 import java.util.HashSet;
  22 import java.util.Set;
  23 import org.junit.BeforeClass;
  24 import org.junit.Test;
  25 import org.opendaylight.yangtools.concepts.SemVer;
  26 import org.opendaylight.yangtools.yang.common.QNameModule;
  27 import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
  28 import org.opendaylight.yangtools.yang.model.api.Module;
  29 import org.opendaylight.yangtools.yang.model.api.ModuleImport;
  30 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  31 import org.opendaylight.yangtools.yang.model.util.FilteringSchemaContextProxy.ModuleId;
  32
  33 public class SchemaContextProxyTest {
  34
  35     private static URI namespace;
  36     private static Date revision;
  37     private static Date revision2;
  38
  39     private static final String CONFIG_NAME = "config";
  40     private static final String ROOT_NAME = "root";
  41     private static final String MODULE2_NAME = "module2";
  42     private static final String MODULE3_NAME = "module3";
  43     private static final String MODULE4_NAME = "module4";
  44     private static final String MODULE41_NAME = "module41";
  45     private static final String MODULE5_NAME = "module5";
  46     private static final String TEST_SOURCE = "test source";
  47
  48     @BeforeClass
  49     public static void setUp() throws ParseException, URISyntaxException {
  50
  51         namespace = new URI("urn:opendaylight:params:xml:ns:yang:controller:config");
  52
  53         revision = SimpleDateFormatUtil.getRevisionFormat().parse("2015-01-01");
  54         revision2 = SimpleDateFormatUtil.getRevisionFormat().parse("2015-01-15");
  55     }
  56
  57     private static SchemaContext mockSchema(final Module... module) {
  58         SchemaContext mock = mock(SchemaContext.class);
  59         doReturn(Sets.newHashSet(module)).when(mock).getModules();
  60         return mock;
  61     }
  62
  63     /**
  64      * <pre>
  65      * CFG(R)
  66      *  | \
  67      *  |  \
  68      * M2 &lt;- M3
  69      * </pre>
  70      */
  71     @Test
  72     public void testBasic() {
  73         Module moduleConfig = mockModule(CONFIG_NAME);
  74         Module module2 = mockModule(MODULE2_NAME);
  75         Module module3 = mockModule(MODULE3_NAME);
  76
  77         mockModuleImport(module2, moduleConfig);
  78         mockModuleImport(module3, module2, moduleConfig);
  79
  80         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
  81
  82         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleConfig);
  83         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
  84     }
  85
  86     /**
  87      * <pre>
  88      * No root or additional modules
  89      *  | \
  90      *  |  \
  91      * M2 &lt;- M3
  92      * </pre>
  93      */
  94     @Test
  95     public void testNull() {
  96         Module moduleConfig = mockModule(CONFIG_NAME);
  97         Module module2 = mockModule(MODULE2_NAME);
  98         Module module3 = mockModule(MODULE3_NAME);
  99
 100         mockModuleImport(module2, moduleConfig);
 101         mockModuleImport(module3, module2, moduleConfig);
 102
 103         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
 104
 105         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, null);
 106         assertProxyContext(filteringSchemaContextProxy, null);
 107     }
 108
 109     /**
 110      * <pre>
 111      *  Config
 112      *  | \ (NR)
 113      *  |  \
 114      * M2 &lt;- M3
 115      * </pre>
 116      */
 117     @Test
 118     public void testConfigDifferentRevisions() {
 119         Module moduleConfigNullRevision = mockModule(CONFIG_NAME, null);
 120         Module moduleConfig = mockModule(CONFIG_NAME, revision);
 121         Module moduleConfig2 = mockModule(CONFIG_NAME, revision2);
 122         Module module2 = mockModule(MODULE2_NAME);
 123         Module module3 = mockModule(MODULE3_NAME);
 124
 125         mockModuleImport(module2, moduleConfig);
 126         mockModuleImport(module3, module2, moduleConfigNullRevision);
 127
 128         SchemaContext schemaContext = mockSchema(moduleConfig, moduleConfig2, module2, module3);
 129
 130         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleConfig);
 131         assertProxyContext(filteringSchemaContextProxy, moduleConfig, moduleConfig2, module2, module3);
 132     }
 133
 134     /**
 135      * <pre>
 136      *     CFG(R)
 137      *    |      \
 138      *   |         \
 139      * M2&lt;-(NullRev)M3
 140      * </pre>
 141      */
 142     @Test
 143     public void testBasicNullRevision() throws Exception {
 144         Module moduleConfig = mockModule(CONFIG_NAME,SimpleDateFormatUtil.getRevisionFormat().parse("2013-04-05"));
 145         Module module2 = mockModule(MODULE2_NAME, SimpleDateFormatUtil.getRevisionFormat().parse("2014-06-17"));
 146         Module module20 = mockModule(MODULE2_NAME, null);
 147         Module module3 = mockModule(MODULE3_NAME, SimpleDateFormatUtil.getRevisionFormat().parse("2014-06-12"));
 148         Module module30 = mockModule(MODULE3_NAME, null);
 149
 150         mockModuleImport(module20, moduleConfig);
 151         mockModuleImport(module2, moduleConfig);
 152         mockModuleImport(module3, module20, moduleConfig);
 153         mockModuleImport(module30, module20, moduleConfig);
 154
 155         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
 156
 157         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleConfig);
 158
 159         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
 160     }
 161
 162     /**
 163      * <pre>
 164      * CFG(R)   ROOT(R)
 165      *  |         \
 166      *  |          \
 167      * M2          M3
 168      * </pre>
 169      */
 170     @Test
 171     public void testBasicMoreRootModules() {
 172         Module moduleConfig = mockModule(CONFIG_NAME);
 173         Module moduleRoot = mockModule(ROOT_NAME);
 174         Module module2 = mockModule(MODULE2_NAME);
 175         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, moduleConfig);
 183         assertProxyContext(filteringSchemaContextProxy, moduleRoot, module3, moduleConfig, module2);
 184     }
 185
 186     /**
 187      * <pre>
 188      * CFG(R)
 189      *  |
 190      *  |
 191      * M2 &lt;- M3
 192      * </pre>
 193      */
 194     @Test
 195     public void testChainNotDepend() {
 196         Module moduleConfig = mockModule(CONFIG_NAME);
 197         Module module2 = mockModule(MODULE2_NAME);
 198         Module module3 = mockModule(MODULE3_NAME);
 199
 200         mockModuleImport(module2, moduleConfig);
 201         mockModuleImport(module3, module2);
 202
 203         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
 204
 205         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleConfig);
 206         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2);
 207     }
 208
 209     /**
 210      * <pre>
 211      * CFG(R)
 212      *  |
 213      *  |
 214      * M2 -&gt; M3 -&gt; M4 -&gt; M5
 215      * </pre>
 216      */
 217     @Test
 218     public void testChainDependMulti() {
 219         Module moduleConfig = mockModule(CONFIG_NAME);
 220         Module module2 = mockModule(MODULE2_NAME);
 221         Module module3 = mockModule(MODULE3_NAME);
 222         Module module4 = mockModule(MODULE4_NAME);
 223         Module module5 = mockModule(MODULE5_NAME);
 224
 225         mockModuleImport(module2, moduleConfig, module3);
 226         mockModuleImport(module3, module4);
 227         mockModuleImport(module4, module5);
 228
 229         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4, module5);
 230
 231         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleConfig);
 232         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4, module5);
 233     }
 234
 235     /**
 236      * <pre>
 237      * CFG(R)
 238      *  |
 239      *  |
 240      * M2 -&gt; M3 &lt;- M4
 241      * </pre>
 242      */
 243     @Test
 244     public void testChainNotDependMulti() {
 245         Module moduleConfig = mockModule(CONFIG_NAME);
 246         Module module2 = mockModule(MODULE2_NAME);
 247         Module module3 = mockModule(MODULE3_NAME);
 248         Module module4 = mockModule(MODULE4_NAME);
 249
 250         mockModuleImport(module2, moduleConfig, module3);
 251         mockModuleImport(module4, module3);
 252
 253         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4);
 254
 255         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleConfig);
 256         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
 257     }
 258
 259     /**
 260      * <pre>
 261      *  CFG(R)
 262      *  | \ \ \
 263      *  |  \ \ \
 264      * M2 M3 M4 M5
 265      * </pre>
 266      */
 267     @Test
 268     public void testChainNotMulti() {
 269         Module moduleConfig = mockModule(CONFIG_NAME);
 270         Module module2 = mockModule(MODULE2_NAME);
 271         Module module3 = mockModule(MODULE3_NAME);
 272         Module module4 = mockModule(MODULE4_NAME);
 273         Module module5 = mockModule(MODULE5_NAME);
 274
 275         mockModuleImport(module2, moduleConfig);
 276         mockModuleImport(module3, moduleConfig);
 277         mockModuleImport(module4, moduleConfig);
 278         mockModuleImport(module5, moduleConfig);
 279
 280         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4, module5);
 281
 282         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleConfig);
 283         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4, module5);
 284     }
 285
 286     /**
 287      * <pre>
 288      * CFG(R)
 289      *  | \
 290      *  |  \
 291      * M2 &lt;- M3 M4=M3(Different revision)
 292      * </pre>
 293      */
 294     @Test
 295     public void testBasicRevisionChange() throws Exception {
 296         Module moduleConfig = mockModule(CONFIG_NAME);
 297         Module module2 = mockModule(MODULE2_NAME);
 298         Module module3 = mockModule(MODULE3_NAME);
 299
 300         Date dat = SimpleDateFormatUtil.getRevisionFormat().parse("2015-10-10");
 301         Module module4 = mockModule(MODULE3_NAME, dat);
 302
 303         mockModuleImport(module2, moduleConfig);
 304         mockModuleImport(module3, module2, moduleConfig);
 305
 306         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4);
 307
 308         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleConfig);
 309         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
 310     }
 311
 312     /**
 313      * <pre>
 314      * CFG(R)
 315      * |
 316      * M2 -(no revision)-&gt; M3(R2) ... M3(R1)
 317      * </pre>
 318      */
 319     @Test
 320     public void testImportNoRevision() {
 321         Module moduleConfig = mockModule(CONFIG_NAME, revision);
 322         Module module2 = mockModule(MODULE2_NAME, revision);
 323
 324         Module module3  = mockModule(MODULE3_NAME, null);
 325         Module module30 = mockModule(MODULE3_NAME, revision);
 326         Module module31 = mockModule(MODULE3_NAME, revision2);
 327         mockModuleImport(module2, moduleConfig, module3);
 328
 329         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module30, module31);
 330
 331         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleConfig);
 332
 333         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module31);
 334     }
 335
 336     /**
 337      * <pre>
 338      * CFG(R)
 339      * |   \
 340      * |    \
 341      * |    M2 -&gt; M3
 342      * |
 343      * M41(S) =&gt; M4
 344      * </pre>
 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, moduleConfig);
 361         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4);
 362     }
 363
 364     /**
 365      * <pre>
 366      *
 367      * M2 -&gt; M3 -&gt; M4 -&gt; M5
 368      *
 369      * </pre>
 370      */
 371     @Test
 372     public void testChainAdditionalModules() {
 373         Module module2 = mockModule(MODULE2_NAME);
 374         Module module3 = mockModule(MODULE3_NAME);
 375         Module module4 = mockModule(MODULE4_NAME);
 376         Module module5 = mockModule(MODULE5_NAME);
 377
 378         mockModuleImport(module2, module3);
 379         mockModuleImport(module3, module4);
 380         mockModuleImport(module4, module5);
 381
 382         SchemaContext schemaContext = mockSchema(module2, module3, module4, module5);
 383
 384         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Sets.newHashSet(module2), null);
 385         assertProxyContext(filteringSchemaContextProxy, module2, module3, module4, module5);
 386     }
 387
 388     /**
 389      * <pre>
 390      *
 391      * CFG(R)
 392      *  |
 393      *  |       M5
 394      * M2
 395      *
 396      * M3 -&gt; M4
 397      *
 398      * </pre>
 399      */
 400     @Test
 401     public void testChainAdditionalModulesConfig() {
 402         Module moduleConfig = mockModule(CONFIG_NAME);
 403         Module module2 = mockModule(MODULE2_NAME);
 404
 405         Module module3 = mockModule(MODULE3_NAME);
 406         Module module4 = mockModule(MODULE4_NAME);
 407         Module module5 = mockModule(MODULE5_NAME);
 408
 409         mockModuleImport(module2, moduleConfig);
 410         mockModuleImport(module3, module4);
 411
 412         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4, module5);
 413
 414         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Sets.newHashSet(module3), moduleConfig);
 415         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4);
 416     }
 417
 418     private static void assertProxyContext(final FilteringSchemaContextProxy filteringSchemaContextProxy, final Module... expected) {
 419
 420         Set<Module> modSet = Sets.newHashSet();
 421
 422         if (expected!=null) {
 423
 424             modSet = Sets.newHashSet(expected);
 425         }
 426
 427         Set<Module> modSetFiltering = filteringSchemaContextProxy.getModules();
 428
 429         assertEquals(modSet, modSetFiltering);
 430
 431         //asserting collections
 432         if (expected!=null) {
 433             for (final Module module : expected) {
 434                 assertEquals(module, filteringSchemaContextProxy.findModuleByName(module.getName(), module.getRevision()));
 435
 436                 Set<Module> mod = filteringSchemaContextProxy.findModuleByNamespace(module.getNamespace());
 437                 assertTrue(mod.contains(module));
 438
 439                 assertEquals(module, filteringSchemaContextProxy.findModuleByNamespaceAndRevision(module.getNamespace(), module.getRevision()));
 440
 441                 assertEquals(module.getSource(), filteringSchemaContextProxy.getModuleSource(module).get());
 442             }
 443         }
 444     }
 445
 446     private static FilteringSchemaContextProxy createProxySchemaCtx(final SchemaContext schemaContext,
 447             final Set<Module> additionalModules, final Module... modules) {
 448
 449         Set<Module> modulesSet = new HashSet<>();
 450
 451         if (modules!=null) {
 452
 453             modulesSet = Sets.newHashSet(modules);
 454
 455         }
 456
 457         return new FilteringSchemaContextProxy(schemaContext, createModuleIds(modulesSet) , createModuleIds(additionalModules));
 458     }
 459
 460     private static Set<ModuleId> createModuleIds(final Set<Module> modules) {
 461
 462         Set<ModuleId> moduleIds = Sets.newHashSet();
 463
 464         if (modules!=null && modules.size()>0) {
 465
 466             for (Module module : modules) {
 467
 468                 moduleIds.add(new ModuleId(module.getName(), module.getRevision()));
 469             }
 470         }
 471
 472         return moduleIds;
 473     }
 474
 475     private static void mockSubmodules(final Module mainModule, final Module... submodules) {
 476
 477         Set<Module> submodulesSet = new HashSet<>();
 478         submodulesSet.addAll(Arrays.asList(submodules));
 479
 480         doReturn(submodulesSet).when(mainModule).getSubmodules();
 481     }
 482
 483     private static void mockModuleImport(final Module importer, final Module... imports) {
 484         Set<ModuleImport> mockedImports = Sets.newHashSet();
 485         for (final Module module : imports) {
 486             mockedImports.add(new ModuleImport() {
 487                 @Override
 488                 public String getModuleName() {
 489                     return module.getName();
 490                 }
 491
 492                 @Override
 493                 public Date getRevision() {
 494                     return module.getRevision();
 495                 }
 496
 497                 @Override
 498                 public String getPrefix() {
 499                     return module.getName();
 500                 }
 501
 502                 @Override
 503                 public SemVer getSemanticVersion() {
 504                     return module.getSemanticVersion();
 505                 }
 506
 507                 @Override
 508                 public String toString() {
 509
 510                     return String.format("Module: %s, revision:%s", module.getName(), module.getRevision());
 511                 }
 512             });
 513         }
 514         doReturn(mockedImports).when(importer).getImports();
 515     }
 516
 517     //mock module with revision
 518     private static Module mockModule(final String name, final Date rev) {
 519
 520         final Module mod = mockModule(name);
 521
 522         doReturn(QNameModule.create(mod.getNamespace(), rev)).when(mod).getQNameModule();
 523         doReturn(rev).when(mod).getRevision();
 524         doReturn(mod.getQNameModule().toString()).when(mod).toString();
 525
 526         return mod;
 527     }
 528
 529     //mock module with default revision
 530     private static Module mockModule(final String mName) {
 531
 532         Module mockedModule = mock(Module.class);
 533         doReturn(mName).when(mockedModule).getName();
 534         doReturn(revision).when(mockedModule).getRevision();
 535         final URI newNamespace = URI.create(namespace.toString() + ":" + mName);
 536         doReturn(newNamespace).when(mockedModule).getNamespace();
 537         doReturn(QNameModule.create(newNamespace, revision)).when(mockedModule).getQNameModule();
 538         doReturn(TEST_SOURCE).when(mockedModule).getSource();
 539         doReturn(Sets.newHashSet()).when(mockedModule).getSubmodules();
 540         doReturn(mockedModule.getQNameModule().toString()).when(mockedModule).toString();
 541         mockModuleImport(mockedModule);
 542
 543         return mockedModule;
 544     }
 545 }