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