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