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