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

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