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