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