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 LeafNode<?> leaf = Builders.leafBuilder().withNodeIdentifier(augmentedLeaf).withValue("").build();
  71         final ContainerNode expectedFilter = Builders
  72                 .containerBuilder()
  73                 .withNodeIdentifier(rootContainer)
  74                 .withChild(
  75                         Builders.containerBuilder()
  76                                 .withNodeIdentifier(outerContainer)
  77                                 .withChild(
  78                                         Builders.augmentationBuilder()
  79                                                 .withNodeIdentifier(augmentation)
  80                                                 .withChild(
  81                                                         leaf).build()).build()).build();
  82
  83         final NormalizedNode<?, ?> filter = ImmutableNodes.fromInstanceId(ctx,
  84                 YangInstanceIdentifier.create(rootContainer, outerContainer, augmentation, augmentedLeaf), leaf);
  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 LeafNode<?> leaf = Builders.leafBuilder().withNodeIdentifier(leafFromCase).withValue("").build();
 111         final ContainerNode expectedFilter = Builders
 112                 .containerBuilder()
 113                 .withNodeIdentifier(rootContainer)
 114                 .withChild(
 115                         Builders.mapBuilder()
 116                                 .withNodeIdentifier(outerList)
 117                                 .withChild(
 118                                         Builders.mapEntryBuilder()
 119                                                 .withNodeIdentifier(outerListWithKey)
 120                                                 .withChild(
 121                                                         Builders.leafBuilder()
 122                                                                 .withNodeIdentifier(
 123                                                                         new NodeIdentifier(ID))
 124                                                                 .withValue(1).build())
 125                                                 .withChild(
 126                                                         Builders.choiceBuilder()
 127                                                                 .withNodeIdentifier(choice)
 128                                                                 .withChild(leaf)
 129                                                                 .build())
 130                                                 .build())
 131                                 .build())
 132                 .build();
 133
 134         final NormalizedNode<?, ?> filter = ImmutableNodes.fromInstanceId(ctx,
 135                 YangInstanceIdentifier.create(rootContainer, outerList, outerListWithKey, choice, leafFromCase), leaf);
 136         assertEquals(expectedFilter, filter);
 137     }
 138
 139     @Test
 140     public void testTopContainerLastChildOverride() throws Exception {
 141         final ContainerNode expectedStructure = Builders
 142                 .containerBuilder()
 143                 .withNodeIdentifier(rootContainer)
 144                 .withChild(
 145                         Builders.mapBuilder()
 146                                 .withNodeIdentifier(outerList)
 147                                 .withChild(
 148                                         Builders.mapEntryBuilder()
 149                                                 .withNodeIdentifier(outerListWithKey)
 150                                                 .withChild(
 151                                                         Builders.leafBuilder()
 152                                                                 .withNodeIdentifier(
 153                                                                         new NodeIdentifier(ID))
 154                                                                 .withValue(1).build())
 155                                                 .withChild(
 156                                                         Builders.choiceBuilder()
 157                                                                 .withNodeIdentifier(choice)
 158                                                                 .withChild(
 159                                                                         Builders.leafBuilder()
 160                                                                                 .withNodeIdentifier(leafFromCase)
 161                                                                                 .withValue("")
 162                                                                                 .build()).build()).build()).build())
 163                 .build();
 164
 165         final NormalizedNode<?, ?> filter = ImmutableNodes.fromInstanceId(ctx,
 166                 YangInstanceIdentifier.create(rootContainer), expectedStructure);
 167         assertEquals(expectedStructure, filter);
 168     }
 169
 170     @Test
 171     public void testListLastChildOverride() throws Exception {
 172         final MapEntryNode outerListEntry = Builders
 173                 .mapEntryBuilder()
 174                 .withNodeIdentifier(outerListWithKey)
 175                 .withChild(
 176                         Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(ID))
 177                                 .withValue(1).build()).build();
 178         final MapNode lastChild = Builders.mapBuilder().withNodeIdentifier(this.outerList).withChild(outerListEntry)
 179                 .build();
 180         final ContainerNode expectedStructure = Builders.containerBuilder().withNodeIdentifier(rootContainer)
 181                 .withChild(lastChild).build();
 182
 183         NormalizedNode<?, ?> filter = ImmutableNodes.fromInstanceId(ctx,
 184                 YangInstanceIdentifier.create(rootContainer, outerList, outerListWithKey), outerListEntry);
 185         assertEquals(expectedStructure, filter);
 186         filter = ImmutableNodes.fromInstanceId(ctx,
 187                 YangInstanceIdentifier.create(rootContainer, outerList, outerListWithKey));
 188         assertEquals(expectedStructure, filter);
 189     }
 190
 191     @Test
 192     public void testLeafList() throws Exception {
 193         final ContainerNode expectedFilter = Builders
 194                 .containerBuilder()
 195                 .withNodeIdentifier(rootContainer)
 196                 .withChild(
 197                         Builders.orderedLeafSetBuilder()
 198                                 .withNodeIdentifier(leafList)
 199                                 .withChild(
 200                                         Builders.leafSetEntryBuilder().withNodeIdentifier(leafListWithValue)
 201                                                 .withValue(leafListWithValue.getValue()).build()).build()).build();
 202
 203         final NormalizedNode<?, ?> filter = ImmutableNodes.fromInstanceId(ctx,
 204                 YangInstanceIdentifier.create(rootContainer, leafList, leafListWithValue));
 205         assertEquals(expectedFilter, filter);
 206     }
 207 }