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