yang/yang-data-impl/src/test/java/org/opendaylight/yangtools/yang/data/impl/schema/InstanceIdToNodesTest.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.data.impl.schema;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import java.io.File;
  12 import java.io.FileNotFoundException;
  13 import java.net.URISyntaxException;
  14 import java.util.Collections;
  15 import org.junit.BeforeClass;
  16 import org.junit.Test;
  17 import org.opendaylight.yangtools.yang.common.QName;
  18 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  19 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
  20 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  21 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
  22 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
  23 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  24 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
  25 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
  26 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
  27 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  28 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  29 import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
  30 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
  31
  32 public class InstanceIdToNodesTest {
  33
  34     private static final String NS = "urn:opendaylight:params:xml:ns:yang:controller:md:sal:normalization:test";
  35     private static final String REVISION = "2014-03-13";
  36     private static final QName ID = QName.create(NS, REVISION, "id");
  37     private static SchemaContext ctx;
  38
  39     private final NodeIdentifier rootContainer = new NodeIdentifier(QName.create(NS, REVISION, "test"));
  40     private final NodeIdentifier outerContainer = new NodeIdentifier(QName.create(NS, REVISION, "outer-container"));
  41     private final NodeIdentifier augmentedLeaf = new NodeIdentifier(QName.create(NS, REVISION, "augmented-leaf"));
  42     private final AugmentationIdentifier augmentation = new AugmentationIdentifier(
  43             Collections.singleton(augmentedLeaf.getNodeType()));
  44
  45     private final NodeIdentifier outerList = new NodeIdentifier(
  46             QName.create(NS, REVISION, "outer-list"));
  47     private final NodeIdentifierWithPredicates outerListWithKey = new NodeIdentifierWithPredicates(
  48             QName.create(NS, REVISION, "outer-list"), ID, 1);
  49     private final NodeIdentifier choice = new NodeIdentifier(QName.create(NS, REVISION, "outer-choice"));
  50     private final NodeIdentifier leafFromCase = new NodeIdentifier(QName.create(NS, REVISION, "one"));
  51
  52     private final NodeIdentifier leafList = new NodeIdentifier(QName.create(NS, REVISION, "ordered-leaf-list"));
  53     private final NodeWithValue<?> leafListWithValue = new NodeWithValue<>(
  54             leafList.getNodeType(), "abcd");
  55
  56     static SchemaContext createTestContext() throws URISyntaxException, FileNotFoundException, ReactorException {
  57         final File resourceFile = new File(InstanceIdToNodesTest.class.getResource("/filter-test.yang").toURI());
  58         return YangParserTestUtils.parseYangSources(resourceFile);
  59     }
  60
  61     @BeforeClass
  62     public static void setUp() throws Exception {
  63         ctx = createTestContext();
  64
  65     }
  66
  67     @Test
  68     public void testInAugment() throws Exception {
  69         final ContainerNode expectedFilter = Builders
  70                 .containerBuilder()
  71                 .withNodeIdentifier(rootContainer)
  72                 .withChild(
  73                         Builders.containerBuilder()
  74                                 .withNodeIdentifier(outerContainer)
  75                                 .withChild(
  76                                         Builders.augmentationBuilder()
  77                                                 .withNodeIdentifier(augmentation)
  78                                                 .withChild(
  79                                                         Builders.leafBuilder().withNodeIdentifier(augmentedLeaf)
  80                                                                 .build()).build()).build()).build();
  81
  82         final NormalizedNode<?, ?> filter = ImmutableNodes.fromInstanceId(ctx,
  83                 YangInstanceIdentifier.create(rootContainer, outerContainer, augmentation, augmentedLeaf));
  84         assertEquals(expectedFilter, filter);
  85     }
  86
  87     @Test
  88     public void testInAugmentLeafOverride() throws Exception {
  89         final LeafNode<Object> lastLeaf = Builders.leafBuilder().withNodeIdentifier(augmentedLeaf)
  90                 .withValue("randomValue").build();
  91
  92         final ContainerNode expectedFilter = Builders
  93                 .containerBuilder()
  94                 .withNodeIdentifier(rootContainer)
  95                 .withChild(
  96                         Builders.containerBuilder()
  97                                 .withNodeIdentifier(outerContainer)
  98                                 .withChild(
  99                                         Builders.augmentationBuilder().withNodeIdentifier(augmentation)
 100                                                 .withChild(lastLeaf).build()).build()).build();
 101
 102         final NormalizedNode<?, ?> filter = ImmutableNodes.fromInstanceId(ctx,
 103                 YangInstanceIdentifier.create(rootContainer, outerContainer, augmentation, augmentedLeaf), lastLeaf);
 104         assertEquals(expectedFilter, filter);
 105     }
 106
 107     @Test
 108     public void testListChoice() throws Exception {
 109         final ContainerNode expectedFilter = Builders
 110                 .containerBuilder()
 111                 .withNodeIdentifier(rootContainer)
 112                 .withChild(
 113                         Builders.mapBuilder()
 114                                 .withNodeIdentifier(outerList)
 115                                 .withChild(
 116                                         Builders.mapEntryBuilder()
 117                                                 .withNodeIdentifier(outerListWithKey)
 118                                                 .withChild(
 119                                                         Builders.leafBuilder()
 120                                                                 .withNodeIdentifier(
 121                                                                         new NodeIdentifier(ID))
 122                                                                 .withValue(1).build())
 123                                                 .withChild(
 124                                                         Builders.choiceBuilder()
 125                                                                 .withNodeIdentifier(choice)
 126                                                                 .withChild(
 127                                                                         Builders.leafBuilder()
 128                                                                                 .withNodeIdentifier(leafFromCase)
 129                                                                                 .build()).build()).build()).build())
 130                 .build();
 131
 132         final NormalizedNode<?, ?> filter = ImmutableNodes.fromInstanceId(ctx,
 133                 YangInstanceIdentifier.create(rootContainer, outerList, outerListWithKey, choice, leafFromCase));
 134         assertEquals(expectedFilter, filter);
 135     }
 136
 137     @Test
 138     public void testTopContainerLastChildOverride() throws Exception {
 139         final ContainerNode expectedStructure = Builders
 140                 .containerBuilder()
 141                 .withNodeIdentifier(rootContainer)
 142                 .withChild(
 143                         Builders.mapBuilder()
 144                                 .withNodeIdentifier(outerList)
 145                                 .withChild(
 146                                         Builders.mapEntryBuilder()
 147                                                 .withNodeIdentifier(outerListWithKey)
 148                                                 .withChild(
 149                                                         Builders.leafBuilder()
 150                                                                 .withNodeIdentifier(
 151                                                                         new NodeIdentifier(ID))
 152                                                                 .withValue(1).build())
 153                                                 .withChild(
 154                                                         Builders.choiceBuilder()
 155                                                                 .withNodeIdentifier(choice)
 156                                                                 .withChild(
 157                                                                         Builders.leafBuilder()
 158                                                                                 .withNodeIdentifier(leafFromCase)
 159                                                                                 .build()).build()).build()).build())
 160                 .build();
 161
 162         final NormalizedNode<?, ?> filter = ImmutableNodes.fromInstanceId(ctx,
 163                 YangInstanceIdentifier.create(rootContainer), expectedStructure);
 164         assertEquals(expectedStructure, filter);
 165     }
 166
 167     @Test
 168     public void testListLastChildOverride() throws Exception {
 169         final MapEntryNode outerListEntry = Builders
 170                 .mapEntryBuilder()
 171                 .withNodeIdentifier(outerListWithKey)
 172                 .withChild(
 173                         Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(ID))
 174                                 .withValue(1).build()).build();
 175         final MapNode lastChild = Builders.mapBuilder().withNodeIdentifier(this.outerList).withChild(outerListEntry)
 176                 .build();
 177         final ContainerNode expectedStructure = Builders.containerBuilder().withNodeIdentifier(rootContainer)
 178                 .withChild(lastChild).build();
 179
 180         NormalizedNode<?, ?> filter = ImmutableNodes.fromInstanceId(ctx,
 181                 YangInstanceIdentifier.create(rootContainer, outerList, outerListWithKey), outerListEntry);
 182         assertEquals(expectedStructure, filter);
 183         filter = ImmutableNodes.fromInstanceId(ctx,
 184                 YangInstanceIdentifier.create(rootContainer, outerList, outerListWithKey));
 185         assertEquals(expectedStructure, filter);
 186     }
 187
 188     @Test
 189     public void testLeafList() throws Exception {
 190         final ContainerNode expectedFilter = Builders
 191                 .containerBuilder()
 192                 .withNodeIdentifier(rootContainer)
 193                 .withChild(
 194                         Builders.orderedLeafSetBuilder()
 195                                 .withNodeIdentifier(leafList)
 196                                 .withChild(
 197                                         Builders.leafSetEntryBuilder().withNodeIdentifier(leafListWithValue)
 198                                                 .withValue(leafListWithValue.getValue()).build()).build()).build();
 199
 200         final NormalizedNode<?, ?> filter = ImmutableNodes.fromInstanceId(ctx,
 201                 YangInstanceIdentifier.create(rootContainer, leafList, leafListWithValue));
 202         assertEquals(expectedFilter, filter);
 203     }
 204 }