yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/impl/AugmentTest.java

   1 /*
   2  * Copyright (c) 2013 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.parser.impl;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertFalse;
  12 import static org.junit.Assert.assertNotNull;
  13 import static org.junit.Assert.assertTrue;
  14
  15 import java.io.FileNotFoundException;
  16 import java.net.URI;
  17 import java.text.DateFormat;
  18 import java.text.ParseException;
  19 import java.text.SimpleDateFormat;
  20 import java.util.ArrayList;
  21 import java.util.Arrays;
  22 import java.util.Collection;
  23 import java.util.Collections;
  24 import java.util.Date;
  25 import java.util.List;
  26 import java.util.Set;
  27
  28 import org.junit.BeforeClass;
  29 import org.junit.Test;
  30 import org.opendaylight.yangtools.yang.common.QName;
  31 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
  32 import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
  33 import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
  34 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
  35 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
  36 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  37 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
  38 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
  39 import org.opendaylight.yangtools.yang.model.api.Module;
  40 import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
  41 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  42 import org.opendaylight.yangtools.yang.model.util.BaseTypes;
  43
  44 public class AugmentTest {
  45     private static final URI fooNS = URI.create("urn:opendaylight.foo");
  46     private static final URI barNS = URI.create("urn:opendaylight.bar");
  47     private static final URI bazNS = URI.create("urn:opendaylight.baz");
  48     private static Date fooRev;
  49     private static Date barRev;
  50     private static Date bazRev;
  51     private static final String foo = "foo";
  52     private static final String bar = "bar";
  53     private static final String baz = "baz";
  54     private static QName q0;
  55     private static QName q1;
  56     private static QName q2;
  57
  58     private Set<Module> modules;
  59
  60     @BeforeClass
  61     public static void init() throws FileNotFoundException, ParseException {
  62         DateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
  63         fooRev = simpleDateFormat.parse("2013-10-13");
  64         barRev = simpleDateFormat.parse("2013-10-14");
  65         bazRev = simpleDateFormat.parse("2013-10-15");
  66
  67         q0 = new QName(barNS, barRev, bar, "interfaces");
  68         q1 = new QName(barNS, barRev, bar, "ifEntry");
  69         q2 = new QName(bazNS, bazRev, baz, "augment-holder");
  70     }
  71
  72     @Test
  73     public void testAugmentParsing() throws Exception {
  74         modules = TestUtils.loadModules(getClass().getResource("/augment-test/augment-in-augment").toURI());
  75         SchemaPath expectedSchemaPath;
  76         List<QName> qnames = new ArrayList<>();
  77         qnames.add(q0);
  78         qnames.add(q1);
  79         qnames.add(q2);
  80
  81         // foo.yang
  82         Module module1 = TestUtils.findModule(modules, "foo");
  83         Set<AugmentationSchema> augmentations = module1.getAugmentations();
  84         assertEquals(1, augmentations.size());
  85         AugmentationSchema augment = augmentations.iterator().next();
  86         assertNotNull(augment);
  87
  88         expectedSchemaPath = SchemaPath.create(qnames, true);
  89         assertEquals(expectedSchemaPath, augment.getTargetPath());
  90
  91         Collection<DataSchemaNode> augmentChildren = augment.getChildNodes();
  92         assertEquals(4, augmentChildren.size());
  93         for (DataSchemaNode dsn : augmentChildren) {
  94             TestUtils.checkIsAugmenting(dsn, false);
  95         }
  96
  97         LeafSchemaNode ds0ChannelNumber = (LeafSchemaNode) augment.getDataChildByName("ds0ChannelNumber");
  98         LeafSchemaNode interfaceId = (LeafSchemaNode) augment.getDataChildByName("interface-id");
  99         ContainerSchemaNode schemas = (ContainerSchemaNode) augment.getDataChildByName("schemas");
 100         ChoiceNode odl = (ChoiceNode) augment.getDataChildByName("odl");
 101
 102         assertNotNull(ds0ChannelNumber);
 103         assertNotNull(interfaceId);
 104         assertNotNull(schemas);
 105         assertNotNull(odl);
 106
 107         // leaf ds0ChannelNumber
 108         QName qname = new QName(fooNS, fooRev, foo, "ds0ChannelNumber");
 109         qnames.add(qname);
 110         assertEquals(qname, ds0ChannelNumber.getQName());
 111         expectedSchemaPath = SchemaPath.create(qnames, true);
 112         assertEquals(expectedSchemaPath, ds0ChannelNumber.getPath());
 113         assertFalse(ds0ChannelNumber.isAugmenting());
 114         // type of leaf ds0ChannelNumber
 115         QName typeQName = BaseTypes.constructQName("string");
 116         List<QName> typePath = Collections.singletonList(typeQName);
 117         expectedSchemaPath = SchemaPath.create(typePath, true);
 118         assertEquals(expectedSchemaPath, ds0ChannelNumber.getType().getPath());
 119
 120         // leaf interface-id
 121         qname = new QName(fooNS, fooRev, foo, "interface-id");
 122         assertEquals(qname, interfaceId.getQName());
 123         qnames.set(3, qname);
 124         expectedSchemaPath = SchemaPath.create(qnames, true);
 125         assertEquals(expectedSchemaPath, interfaceId.getPath());
 126         assertFalse(interfaceId.isAugmenting());
 127
 128         // container schemas
 129         qname = new QName(fooNS, fooRev, foo, "schemas");
 130         assertEquals(qname, schemas.getQName());
 131         qnames.set(3, qname);
 132         expectedSchemaPath = SchemaPath.create(qnames, true);
 133         assertEquals(expectedSchemaPath, schemas.getPath());
 134         assertFalse(schemas.isAugmenting());
 135
 136         // choice odl
 137         qname = new QName(fooNS, fooRev, foo, "odl");
 138         assertEquals(qname, odl.getQName());
 139         qnames.set(3, qname);
 140         expectedSchemaPath = SchemaPath.create(qnames, true);
 141         assertEquals(expectedSchemaPath, odl.getPath());
 142         assertFalse(odl.isAugmenting());
 143
 144         // baz.yang
 145         Module module3 = TestUtils.findModule(modules, "baz");
 146         augmentations = module3.getAugmentations();
 147         assertEquals(3, augmentations.size());
 148         AugmentationSchema augment1 = null;
 149         AugmentationSchema augment2 = null;
 150         AugmentationSchema augment3 = null;
 151         for (AugmentationSchema as : augmentations) {
 152             if (as.getWhenCondition() == null) {
 153                 augment3 = as;
 154             } else if ("if:ifType='ds0'".equals(as.getWhenCondition().toString())) {
 155                 augment1 = as;
 156             } else if ("if:ifType='ds2'".equals(as.getWhenCondition().toString())) {
 157                 augment2 = as;
 158             }
 159         }
 160         assertNotNull(augment1);
 161         assertNotNull(augment2);
 162         assertNotNull(augment3);
 163
 164         assertEquals(1, augment1.getChildNodes().size());
 165         ContainerSchemaNode augmentHolder = (ContainerSchemaNode) augment1.getDataChildByName("augment-holder");
 166         assertNotNull(augmentHolder);
 167
 168         assertEquals(1, augment2.getChildNodes().size());
 169         ContainerSchemaNode augmentHolder2 = (ContainerSchemaNode) augment2.getDataChildByName("augment-holder2");
 170         assertNotNull(augmentHolder2);
 171
 172         assertEquals(1, augment3.getChildNodes().size());
 173         LeafSchemaNode pause = (LeafSchemaNode) augment3.getDataChildByName("pause");
 174         assertNotNull(pause);
 175     }
 176
 177     @Test
 178     public void testAugmentResolving() throws Exception {
 179         modules = TestUtils.loadModules(getClass().getResource("/augment-test/augment-in-augment").toURI());
 180         Module module2 = TestUtils.findModule(modules, "bar");
 181         ContainerSchemaNode interfaces = (ContainerSchemaNode) module2.getDataChildByName("interfaces");
 182         ListSchemaNode ifEntry = (ListSchemaNode) interfaces.getDataChildByName("ifEntry");
 183
 184         SchemaPath expectedPath;
 185         List<QName> qnames = new ArrayList<>();
 186         qnames.add(q0);
 187         qnames.add(q1);
 188         qnames.add(q2);
 189
 190         // baz.yang
 191         // augment "/br:interfaces/br:ifEntry" {
 192         ContainerSchemaNode augmentHolder = (ContainerSchemaNode) ifEntry.getDataChildByName("augment-holder");
 193         TestUtils.checkIsAugmenting(augmentHolder, true);
 194         assertEquals(q2, augmentHolder.getQName());
 195         expectedPath = SchemaPath.create(qnames, true);
 196         assertEquals(expectedPath, augmentHolder.getPath());
 197
 198         // foo.yang
 199         // augment "/br:interfaces/br:ifEntry/bz:augment-holder"
 200         LeafSchemaNode ds0ChannelNumber = (LeafSchemaNode) augmentHolder.getDataChildByName("ds0ChannelNumber");
 201         LeafSchemaNode interfaceId = (LeafSchemaNode) augmentHolder.getDataChildByName("interface-id");
 202         ContainerSchemaNode schemas = (ContainerSchemaNode) augmentHolder.getDataChildByName("schemas");
 203         ChoiceNode odl = (ChoiceNode) augmentHolder.getDataChildByName("odl");
 204
 205         assertNotNull(ds0ChannelNumber);
 206         assertNotNull(interfaceId);
 207         assertNotNull(schemas);
 208         assertNotNull(odl);
 209
 210         // leaf ds0ChannelNumber
 211         QName qname = new QName(fooNS, fooRev, foo, "ds0ChannelNumber");
 212         assertEquals(qname, ds0ChannelNumber.getQName());
 213         qnames.add(qname);
 214         expectedPath = SchemaPath.create(qnames, true);
 215         assertEquals(expectedPath, ds0ChannelNumber.getPath());
 216
 217         // leaf interface-id
 218         qname = new QName(fooNS, fooRev, foo, "interface-id");
 219         assertEquals(qname, interfaceId.getQName());
 220         qnames.set(3, qname);
 221         expectedPath = SchemaPath.create(qnames, true);
 222         assertEquals(expectedPath, interfaceId.getPath());
 223
 224         // container schemas
 225         qname = new QName(fooNS, fooRev, foo, "schemas");
 226         assertEquals(qname, schemas.getQName());
 227         qnames.set(3, qname);
 228         expectedPath = SchemaPath.create(qnames, true);
 229         assertEquals(expectedPath, schemas.getPath());
 230
 231         // choice odl
 232         qname = new QName(fooNS, fooRev, foo, "odl");
 233         assertEquals(qname, odl.getQName());
 234         qnames.set(3, qname);
 235         expectedPath = SchemaPath.create(qnames, true);
 236         assertEquals(expectedPath, odl.getPath());
 237     }
 238
 239     @Test
 240     public void testAugmentedChoice() throws Exception {
 241         modules = TestUtils.loadModules(getClass().getResource("/augment-test/augment-in-augment").toURI());
 242         Module module2 = TestUtils.findModule(modules, "bar");
 243         ContainerSchemaNode interfaces = (ContainerSchemaNode) module2.getDataChildByName("interfaces");
 244         ListSchemaNode ifEntry = (ListSchemaNode) interfaces.getDataChildByName("ifEntry");
 245         ContainerSchemaNode augmentedHolder = (ContainerSchemaNode) ifEntry.getDataChildByName("augment-holder");
 246         TestUtils.checkIsAugmenting(augmentedHolder, true);
 247
 248         // foo.yang
 249         // augment "/br:interfaces/br:ifEntry/bz:augment-holder"
 250         ChoiceNode odl = (ChoiceNode) augmentedHolder.getDataChildByName("odl");
 251         assertNotNull(odl);
 252         Set<ChoiceCaseNode> cases = odl.getCases();
 253         assertEquals(4, cases.size());
 254
 255         ChoiceCaseNode id = null;
 256         ChoiceCaseNode node1 = null;
 257         ChoiceCaseNode node2 = null;
 258         ChoiceCaseNode node3 = null;
 259
 260         for (ChoiceCaseNode ccn : cases) {
 261             if ("id".equals(ccn.getQName().getLocalName())) {
 262                 id = ccn;
 263             } else if ("node1".equals(ccn.getQName().getLocalName())) {
 264                 node1 = ccn;
 265             } else if ("node2".equals(ccn.getQName().getLocalName())) {
 266                 node2 = ccn;
 267             } else if ("node3".equals(ccn.getQName().getLocalName())) {
 268                 node3 = ccn;
 269             }
 270         }
 271
 272         assertNotNull(id);
 273         assertNotNull(node1);
 274         assertNotNull(node2);
 275         assertNotNull(node3);
 276
 277         SchemaPath expectedPath;
 278         List<QName> qnames = new ArrayList<>();
 279         qnames.add(q0);
 280         qnames.add(q1);
 281         qnames.add(q2);
 282         qnames.add(new QName(fooNS, fooRev, foo, "odl"));
 283
 284         // case id
 285         QName qname = new QName(fooNS, fooRev, foo, "id");
 286         assertEquals(qname, id.getQName());
 287         qnames.add(qname);
 288         expectedPath = SchemaPath.create(qnames, true);
 289         assertEquals(expectedPath, id.getPath());
 290         Collection<DataSchemaNode> idChildren = id.getChildNodes();
 291         assertEquals(1, idChildren.size());
 292
 293         // case node1
 294         qname = new QName(fooNS, fooRev, foo, "node1");
 295         assertEquals(qname, node1.getQName());
 296         qnames.set(4, qname);
 297         expectedPath = SchemaPath.create(qnames, true);
 298         assertEquals(expectedPath, node1.getPath());
 299         Collection<DataSchemaNode> node1Children = node1.getChildNodes();
 300         assertTrue(node1Children.isEmpty());
 301
 302         // case node2
 303         qname = new QName(fooNS, fooRev, foo, "node2");
 304         assertEquals(qname, node2.getQName());
 305         qnames.set(4, qname);
 306         expectedPath = SchemaPath.create(qnames, true);
 307         assertEquals(expectedPath, node2.getPath());
 308         Collection<DataSchemaNode> node2Children = node2.getChildNodes();
 309         assertTrue(node2Children.isEmpty());
 310
 311         // case node3
 312         qname = new QName(fooNS, fooRev, foo, "node3");
 313         assertEquals(qname, node3.getQName());
 314         qnames.set(4, qname);
 315         expectedPath = SchemaPath.create(qnames, true);
 316         assertEquals(expectedPath, node3.getPath());
 317         Collection<DataSchemaNode> node3Children = node3.getChildNodes();
 318         assertEquals(1, node3Children.size());
 319
 320         // test cases
 321         qnames.clear();
 322         qnames.add(q0);
 323         qnames.add(q1);
 324         qnames.add(q2);
 325         qnames.add(new QName(fooNS, fooRev, foo, "odl"));
 326
 327         // case id child
 328         qnames.add(new QName(fooNS, fooRev, foo, "id"));
 329         qnames.add(new QName(fooNS, fooRev, foo, "id"));
 330         LeafSchemaNode caseIdChild = (LeafSchemaNode) idChildren.iterator().next();
 331         assertNotNull(caseIdChild);
 332         expectedPath = SchemaPath.create(qnames, true);
 333         assertEquals(expectedPath, caseIdChild.getPath());
 334
 335         // case node3 child
 336         qnames.set(4, new QName(fooNS, fooRev, foo, "node3"));
 337         qnames.set(5, new QName(fooNS, fooRev, foo, "node3"));
 338         ContainerSchemaNode caseNode3Child = (ContainerSchemaNode) node3Children.iterator().next();
 339         assertNotNull(caseNode3Child);
 340         expectedPath = SchemaPath.create(qnames, true);
 341         assertEquals(expectedPath, caseNode3Child.getPath());
 342     }
 343
 344     @Test
 345     public void testAugmentRpc() throws Exception {
 346         modules = TestUtils.loadModules(getClass().getResource("/augment-test/rpc").toURI());
 347         final URI NS_BAR = URI.create("urn:opendaylight:bar");
 348         final URI NS_FOO = URI.create("urn:opendaylight:foo");
 349         final Date revision = new SimpleDateFormat("yyyy-MM-dd").parse("2013-10-11");
 350
 351         Module bar = TestUtils.findModule(modules, "bar");
 352         Set<RpcDefinition> rpcs = bar.getRpcs();
 353         assertEquals(2, rpcs.size());
 354
 355         RpcDefinition submit = null;
 356         for (RpcDefinition rpc : rpcs) {
 357             if ("submit".equals(rpc.getQName().getLocalName())) {
 358                 submit = rpc;
 359                 break;
 360             }
 361         }
 362         assertNotNull(submit);
 363
 364         QName submitQName = new QName(NS_BAR, revision, "b", "submit");
 365         assertEquals(submitQName, submit.getQName());
 366         ContainerSchemaNode input = submit.getInput();
 367         QName inputQName = new QName(NS_BAR, revision, "b", "input");
 368         assertEquals(inputQName, input.getQName());
 369         ChoiceNode arguments = (ChoiceNode) input.getDataChildByName("arguments");
 370         QName argumentsQName = new QName(NS_BAR, revision, "b", "arguments");
 371         assertEquals(argumentsQName, arguments.getQName());
 372         assertFalse(arguments.isAugmenting());
 373         Set<ChoiceCaseNode> cases = arguments.getCases();
 374         assertEquals(3, cases.size());
 375
 376         ChoiceCaseNode attach = null;
 377         ChoiceCaseNode create = null;
 378         ChoiceCaseNode destroy = null;
 379         for (ChoiceCaseNode child : cases) {
 380             if ("attach".equals(child.getQName().getLocalName())) {
 381                 attach = child;
 382             } else if ("create".equals(child.getQName().getLocalName())) {
 383                 create = child;
 384             } else if ("destroy".equals(child.getQName().getLocalName())) {
 385                 destroy = child;
 386             }
 387         }
 388         assertNotNull(attach);
 389         assertNotNull(create);
 390         assertNotNull(destroy);
 391
 392         assertTrue(attach.isAugmenting());
 393         assertTrue(create.isAugmenting());
 394         assertTrue(destroy.isAugmenting());
 395
 396         SchemaPath expectedPath;
 397         QName[] qnames = new QName[4];
 398         qnames[0] = submitQName;
 399         qnames[1] = inputQName;
 400         qnames[2] = argumentsQName;
 401
 402         // case attach
 403         qnames[3] = new QName(NS_FOO, revision, "f", "attach");
 404         assertEquals(qnames[3], attach.getQName());
 405         expectedPath = SchemaPath.create(Arrays.asList(qnames), true);
 406         assertEquals(expectedPath, attach.getPath());
 407         Collection<DataSchemaNode> attachChildren = attach.getChildNodes();
 408         assertEquals(1, attachChildren.size());
 409
 410         // case create
 411         qnames[3] = new QName(NS_FOO, revision, "f", "create");
 412         assertEquals(qnames[3], create.getQName());
 413         expectedPath = SchemaPath.create(Arrays.asList(qnames), true);
 414         assertEquals(expectedPath, create.getPath());
 415         Collection<DataSchemaNode> createChildren = create.getChildNodes();
 416         assertEquals(1, createChildren.size());
 417
 418         // case attach
 419         qnames[3] = new QName(NS_FOO, revision, "f", "destroy");
 420         assertEquals(qnames[3], destroy.getQName());
 421         expectedPath = SchemaPath.create(Arrays.asList(qnames), true);
 422         assertEquals(expectedPath, destroy.getPath());
 423         Collection<DataSchemaNode> destroyChildren = destroy.getChildNodes();
 424         assertEquals(1, destroyChildren.size());
 425     }
 426
 427     @Test
 428     public void testAugmentInUsesResolving() throws Exception {
 429         modules = TestUtils.loadModules(getClass().getResource("/augment-test/augment-in-uses").toURI());
 430         assertEquals(1, modules.size());
 431
 432         Module test = modules.iterator().next();
 433         DataNodeContainer links = (DataNodeContainer) test.getDataChildByName("links");
 434         DataNodeContainer link = (DataNodeContainer) links.getDataChildByName("link");
 435         DataNodeContainer nodes = (DataNodeContainer) link.getDataChildByName("nodes");
 436         ContainerSchemaNode node = (ContainerSchemaNode) nodes.getDataChildByName("node");
 437         Set<AugmentationSchema> augments = node.getAvailableAugmentations();
 438         assertEquals(1, augments.size());
 439         assertEquals(1, node.getChildNodes().size());
 440         LeafSchemaNode id = (LeafSchemaNode) node.getDataChildByName("id");
 441         assertTrue(id.isAugmenting());
 442     }
 443
 444 }