restconf/restconf-nb/src/test/java/org/opendaylight/restconf/nb/rfc8040/utils/parser/YangInstanceIdentifierSerializerTest.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.restconf.nb.rfc8040.utils.parser;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertThrows;
  12 import static org.junit.Assert.assertTrue;
  13
  14 import java.util.LinkedHashMap;
  15 import java.util.Map;
  16 import org.junit.AfterClass;
  17 import org.junit.BeforeClass;
  18 import org.junit.Test;
  19 import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
  20 import org.opendaylight.yangtools.yang.common.QName;
  21 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  22 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
  23 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
  24 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
  25 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
  26
  27 /**
  28  * Unit tests for {@link YangInstanceIdentifierSerializer}.
  29  */
  30 public class YangInstanceIdentifierSerializerTest {
  31     // schema context with test modules
  32     private static EffectiveModelContext SCHEMA_CONTEXT;
  33
  34     @BeforeClass
  35     public static void beforeClass() {
  36         SCHEMA_CONTEXT = YangParserTestUtils.parseYangResourceDirectory("/restconf/parser/serializer");
  37     }
  38
  39     @AfterClass
  40     public static void afterClass() {
  41         SCHEMA_CONTEXT = null;
  42     }
  43
  44     /**
  45      * Positive test of serialization of <code>YangInstanceIdentifier</code> containing container node to
  46      * <code>String</code>. Returned <code>String</code> is compared to have expected value.
  47      */
  48     @Test
  49     public void serializeContainerTest() {
  50         final YangInstanceIdentifier data = YangInstanceIdentifier.builder()
  51                 .node(QName.create("serializer:test", "2016-06-06", "contA"))
  52                 .build();
  53
  54         final String result = YangInstanceIdentifierSerializer.create(SCHEMA_CONTEXT, data);
  55         assertEquals("Serialization not successful",
  56                 "serializer-test:contA", result);
  57     }
  58
  59     /**
  60      * Positive test of serialization of <code>YangInstanceIdentifier</code> containing container with leaf node to
  61      * <code>String</code>. Returned <code>String</code> is compared to have expected value.
  62      */
  63     @Test
  64     public void serializeContainerWithLeafTest() {
  65         final YangInstanceIdentifier data = YangInstanceIdentifier.builder()
  66                 .node(QName.create("serializer:test", "2016-06-06", "contA"))
  67                 .node(QName.create("serializer:test", "2016-06-06", "leaf-A"))
  68                 .build();
  69
  70         final String result = YangInstanceIdentifierSerializer.create(SCHEMA_CONTEXT, data);
  71         assertEquals("Serialization not successful", "serializer-test:contA/leaf-A", result);
  72     }
  73
  74     /**
  75      * Positive test of serialization of <code>YangInstanceIdentifier</code> containing container with list with leaf
  76      * list node to <code>String</code>. Returned <code>String</code> is compared to have expected value.
  77      */
  78     @Test
  79     public void serializeContainerWithListWithLeafListTest() {
  80         final QName list = QName.create("serializer:test", "2016-06-06", "list-A");
  81         final QName leafList = QName.create("serializer:test", "2016-06-06", "leaf-list-AA");
  82
  83         final YangInstanceIdentifier data = YangInstanceIdentifier.builder()
  84                 .node(QName.create("serializer:test", "2016-06-06", "contA"))
  85                 .node(list)
  86                 .node(NodeIdentifierWithPredicates.of(list, QName.create(list, "list-key"), 100))
  87                 .node(leafList)
  88                 .node(new NodeWithValue<>(leafList, "instance"))
  89                 .build();
  90
  91         final String result = YangInstanceIdentifierSerializer.create(SCHEMA_CONTEXT, data);
  92         assertEquals("Serialization not successful",
  93                 "serializer-test:contA/list-A=100/leaf-list-AA=instance",
  94                 result);
  95     }
  96
  97     /**
  98      * Positive test of serialization of <code>YangInstanceIdentifier</code> to <code>String</code> when serialized
  99      * <code>YangInstanceIdentifier</code> contains list with no keys. Returned <code>String</code> is compared to have
 100      * expected value.
 101      */
 102     @Test
 103     public void serializeListWithNoKeysTest() {
 104         final YangInstanceIdentifier data = YangInstanceIdentifier.builder()
 105                 .node(QName.create("serializer:test", "2016-06-06", "list-no-key"))
 106                 .node(QName.create("serializer:test", "2016-06-06", "list-no-key"))
 107                 .build();
 108
 109         final String result = YangInstanceIdentifierSerializer.create(SCHEMA_CONTEXT, data);
 110         assertEquals("Serialization not successful", "serializer-test:list-no-key", result);
 111     }
 112
 113     /**
 114      * Positive test of serialization of <code>YangInstanceIdentifier</code> to <code>String</code> when serialized
 115      * <code>YangInstanceIdentifier</code> contains a keyed list, but the path argument does not specify them. Returned
 116      * <code>String</code> is compared to have expected value.
 117      */
 118     @Test
 119     public void serializeMapWithNoKeysTest() {
 120         final YangInstanceIdentifier data = YangInstanceIdentifier.builder()
 121                 .node(QName.create("serializer:test", "2016-06-06", "list-one-key"))
 122                 .nodeWithKey(QName.create("serializer:test", "2016-06-06", "list-one-key"), Map.of())
 123                 .build();
 124
 125         final String result = YangInstanceIdentifierSerializer.create(SCHEMA_CONTEXT, data);
 126         assertEquals("Serialization not successful", "serializer-test:list-one-key", result);
 127     }
 128
 129     /**
 130      * Positive test of serialization of <code>YangInstanceIdentifier</code> to <code>String</code> when serialized
 131      * <code>YangInstanceIdentifier</code> contains list with one key. Returned <code>String</code> is compared to have
 132      * expected value.
 133      */
 134     @Test
 135     public void serializeMapWithOneKeyTest() {
 136         final YangInstanceIdentifier data = YangInstanceIdentifier.builder()
 137                 .node(QName.create("serializer:test", "2016-06-06", "list-one-key"))
 138                 .nodeWithKey(QName.create("serializer:test", "2016-06-06", "list-one-key"),
 139                         QName.create("serializer:test", "2016-06-06", "list-one-key"), "value")
 140                 .build();
 141
 142         final String result = YangInstanceIdentifierSerializer.create(SCHEMA_CONTEXT, data);
 143         assertEquals("Serialization not successful", "serializer-test:list-one-key=value", result);
 144     }
 145
 146     /**
 147      * Positive test of serialization of <code>YangInstanceIdentifier</code> to <code>String</code> when serialized
 148      * <code>YangInstanceIdentifier</code> contains list with multiple keys. Returned <code>String</code> is compared
 149      * to have expected value.
 150      */
 151     @Test
 152     public void serializeMapWithMultipleKeysTest() {
 153         final QName list = QName.create("serializer:test", "2016-06-06", "list-multiple-keys");
 154         final Map<QName, Object> values = new LinkedHashMap<>();
 155         values.put(QName.create(list, "name"), "value-1");
 156         values.put(QName.create(list, "number"), "2");
 157         values.put(QName.create(list, "enabled"), "true");
 158
 159         final YangInstanceIdentifier data = YangInstanceIdentifier.builder()
 160                 .node(list).nodeWithKey(list, values).build();
 161
 162         final String result = YangInstanceIdentifierSerializer.create(SCHEMA_CONTEXT, data);
 163         assertEquals("Serialization not successful", "serializer-test:list-multiple-keys=value-1,2,true", result);
 164     }
 165
 166     /**
 167      * Positive test of serialization of <code>YangInstanceIdentifier</code> to <code>String</code> when serialized
 168      * <code>YangInstanceIdentifier</code> contains leaf node. Returned <code>String</code> is compared to have
 169      * expected value.
 170      */
 171     @Test
 172     public void serializeLeafTest() {
 173         final YangInstanceIdentifier data = YangInstanceIdentifier.builder()
 174                 .node(QName.create("serializer:test", "2016-06-06", "leaf-0"))
 175                 .build();
 176
 177         final String result = YangInstanceIdentifierSerializer.create(SCHEMA_CONTEXT, data);
 178         assertEquals("Serialization not successful", "serializer-test:leaf-0", result);
 179     }
 180
 181     /**
 182      * Positive test of serialization of <code>YangInstanceIdentifier</code> to <code>String</code> when serialized
 183      * <code>YangInstanceIdentifier</code> contains leaf list node. Returned <code>String</code> is compared to have
 184      * expected value.
 185      */
 186     @Test
 187     public void serializeLeafListTest() {
 188         final YangInstanceIdentifier data = YangInstanceIdentifier.builder()
 189                 .node(QName.create("serializer:test", "2016-06-06", "leaf-list-0"))
 190                 .node(new NodeWithValue<>(QName.create("serializer:test", "2016-06-06", "leaf-list-0"), "instance"))
 191                 .build();
 192
 193         final String result = YangInstanceIdentifierSerializer.create(SCHEMA_CONTEXT, data);
 194         assertEquals("Serialization not successful", "serializer-test:leaf-list-0=instance", result);
 195     }
 196
 197     /**
 198      * Negative test of serialization <code>YangInstanceIdentifier</code> to <code>String</code> when
 199      * <code>SchemaContext</code> is <code>null</code>. Test is expected to fail with
 200      * <code>NullPointerException</code>.
 201      */
 202     @Test
 203     public void serializeNullSchemaContextNegativeTest() {
 204         assertThrows(NullPointerException.class,
 205             () -> YangInstanceIdentifierSerializer.create(null, YangInstanceIdentifier.of()));
 206     }
 207
 208     /**
 209      * Negative test of serialization <code>YangInstanceIdentifier</code> to <code>String</code> when supplied
 210      * <code>YangInstanceIdentifier</code> is <code>null</code>. Test is expected to fail with
 211      * <code>NullPointerException</code>.
 212      */
 213     @Test
 214     public void serializeNullDataNegativeTest() {
 215         assertThrows(NullPointerException.class,
 216             () -> YangInstanceIdentifierSerializer.create(SCHEMA_CONTEXT, null));
 217     }
 218
 219     /**
 220      * Test of serialization <code>YangInstanceIdentifier</code> to <code>String</code> when supplied
 221      * <code>YangInstanceIdentifier</code> is <code>YangInstanceIdentifier.EMPTY</code>.
 222      * Empty <code>String</code> is expected as a return value.
 223      */
 224     @Test
 225     public void serializeEmptyDataTest() {
 226         final String result = YangInstanceIdentifierSerializer.create(SCHEMA_CONTEXT, YangInstanceIdentifier.of());
 227         assertTrue("Empty identifier is expected", result.isEmpty());
 228     }
 229
 230     /**
 231      * Negative test when it is not possible to find child node of current node. Test is expected to fail with
 232      * <code>RestconfDocumentedException</code> and error message is compared to expected error message.
 233      */
 234     @Test
 235     public void serializeChildNodeNotFoundNegativeTest() {
 236         final YangInstanceIdentifier data = YangInstanceIdentifier.builder()
 237                 .node(QName.create("serializer:test", "2016-06-06", "contA"))
 238                 .node(QName.create("serializer:test", "2016-06-06", "not-existing-leaf"))
 239                 .build();
 240
 241         assertThrows(RestconfDocumentedException.class,
 242             () -> YangInstanceIdentifierSerializer.create(SCHEMA_CONTEXT, data));
 243     }
 244
 245     /**
 246      * Test if URIs with percent encoded characters are all correctly serialized.
 247      */
 248     @Test
 249     public void serializePercentEncodingTest() {
 250         final String value = "foo:foo bar/foo,bar/'bar'";
 251         final String encoded = "foo%3Afoo%20bar%2Ffoo%2Cbar%2F%27bar%27";
 252
 253         final YangInstanceIdentifier data = YangInstanceIdentifier.builder()
 254                 .node(QName.create("serializer:test", "2016-06-06", "list-one-key"))
 255                 .nodeWithKey(QName.create("serializer:test", "2016-06-06", "list-one-key"),
 256                         QName.create("serializer:test", "2016-06-06", "list-one-key"), value)
 257                 .build();
 258
 259         final String result = YangInstanceIdentifierSerializer.create(SCHEMA_CONTEXT, data);
 260         assertEquals("Serialization not successful", "serializer-test:list-one-key=" + encoded, result);
 261     }
 262
 263     /**
 264      * Test if URIs with no percent encoded characters are correctly serialized. Input should be untouched.
 265      */
 266     @Test
 267     public void serializeNoPercentEncodingTest() {
 268         final String value = "foo\"b\"bar";
 269
 270         final YangInstanceIdentifier data = YangInstanceIdentifier.builder()
 271                 .node(QName.create("serializer:test", "2016-06-06", "list-one-key"))
 272                 .nodeWithKey(QName.create("serializer:test", "2016-06-06", "list-one-key"),
 273                         QName.create("serializer:test", "2016-06-06", "list-one-key"), value)
 274                 .build();
 275
 276         final String result = YangInstanceIdentifierSerializer.create(SCHEMA_CONTEXT, data);
 277         assertEquals("Serialization not successful", "serializer-test:list-one-key=" + value, result);
 278     }
 279
 280     /**
 281      * Test of serialization when nodes in input <code>YangInstanceIdentifier</code> are defined in two different
 282      * modules by using augmentation.
 283      */
 284     @Test
 285     public void serializeIncludedNodesTest() {
 286         final QName list = QName.create("serializer:test:included", "2016-06-06", "augmented-list");
 287         final QName child = QName.create("serializer:test", "2016-06-06", "augmented-leaf");
 288
 289         final YangInstanceIdentifier data = YangInstanceIdentifier.builder()
 290                 .node(list)
 291                 .node(NodeIdentifierWithPredicates.of(list, QName.create(list, "list-key"), 100))
 292                 .node(child)
 293                 .build();
 294
 295         final String result = YangInstanceIdentifierSerializer.create(SCHEMA_CONTEXT, data);
 296
 297         assertEquals("Serialization not successful",
 298                 "serializer-test-included:augmented-list=100/serializer-test:augmented-leaf", result);
 299     }
 300
 301     /**
 302      * Test of serialization when nodes in input <code>YangInstanceIdentifier</code> are defined in two different
 303      * modules by using augmentation. Augmented node in data supplied for serialization has wrong namespace.
 304      * <code>RestconfDocumentedException</code> is expected because augmented node is defined in other module than its
 305      * parent and will not be found.
 306      */
 307     @Test
 308     public void serializeIncludedNodesSerializationTest() {
 309         final QName list = QName.create("serializer:test:included", "2016-06-06", "augmented-list");
 310         // child should has different namespace
 311         final QName child = QName.create("serializer:test:included", "2016-06-06", "augmented-leaf");
 312
 313         final YangInstanceIdentifier data = YangInstanceIdentifier.builder()
 314                 .node(list)
 315                 .node(NodeIdentifierWithPredicates.of(list, QName.create(list, "list-key"), 100))
 316                 .node(child)
 317                 .build();
 318
 319         assertThrows(RestconfDocumentedException.class,
 320             () -> YangInstanceIdentifierSerializer.create(SCHEMA_CONTEXT, data));
 321     }
 322 }