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