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