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