restconf/restconf-nb-rfc8040/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.assertTrue;
  12
  13 import com.google.common.collect.ImmutableSet;
  14 import java.util.HashMap;
  15 import java.util.LinkedHashMap;
  16 import java.util.Map;
  17 import org.junit.Before;
  18 import org.junit.Rule;
  19 import org.junit.Test;
  20 import org.junit.rules.ExpectedException;
  21 import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
  22 import org.opendaylight.restconf.nb.rfc8040.TestRestconfUtils;
  23 import org.opendaylight.restconf.nb.rfc8040.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.AugmentationIdentifier;
  27 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
  28 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
  29 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  30 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
  31
  32 /**
  33  * Unit tests for {@link YangInstanceIdentifierSerializer}.
  34  */
  35 public class YangInstanceIdentifierSerializerTest {
  36
  37     @Rule
  38     public ExpectedException thrown = ExpectedException.none();
  39
  40     // schema context with test modules
  41     private SchemaContext schemaContext;
  42
  43     @Before
  44     public void init() throws Exception {
  45         this.schemaContext =
  46                 YangParserTestUtils.parseYangFiles(TestRestconfUtils.loadFiles("/restconf/parser/serializer"));
  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(this.schemaContext, 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(this.schemaContext, 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(this.schemaContext, 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(this.schemaContext, 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(this.schemaContext, 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(this.schemaContext, 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(this.schemaContext, 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(this.schemaContext, 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         this.thrown.expect(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         this.thrown.expect(NullPointerException.class);
 205         YangInstanceIdentifierSerializer.create(this.schemaContext, 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(this.schemaContext,
 216             YangInstanceIdentifier.empty());
 217         assertTrue("Empty identifier is expected", result.isEmpty());
 218     }
 219
 220     /**
 221      * Negative test when it is not possible to find child node of current node. Test is expected to fail with
 222      * <code>RestconfDocumentedException</code> and error message is compared to expected error message.
 223      */
 224     @Test
 225     public void serializeChildNodeNotFoundNegativeTest() {
 226         final YangInstanceIdentifier data = YangInstanceIdentifier.builder()
 227                 .node(QName.create("serializer:test", "2016-06-06", "contA"))
 228                 .node(QName.create("serializer:test", "2016-06-06", "not-existing-leaf"))
 229                 .build();
 230
 231         this.thrown.expect(RestconfDocumentedException.class);
 232         YangInstanceIdentifierSerializer.create(this.schemaContext, data);
 233     }
 234
 235     /**
 236      * Test to verify if all reserved characters according to rfc3986 are considered by serializer implementation to
 237      * be percent encoded.
 238      */
 239     @Test
 240     public void verifyReservedCharactersTest() {
 241         final char[] genDelims = { ':', '/', '?', '#', '[', ']', '@' };
 242         final char[] subDelims = { '!', '$', '&', '\'', '(', ')', '*', '+', ',', ';', '=' };
 243
 244         for (final char c : genDelims) {
 245             assertTrue("Current character is reserved and should be percent encoded",
 246                     ParserBuilderConstants.Serializer.PERCENT_ENCODE_CHARS.matches(c));
 247         }
 248
 249         for (final char c : subDelims) {
 250             assertTrue("Current character is reserved and should be percent encoded",
 251                     ParserBuilderConstants.Serializer.PERCENT_ENCODE_CHARS.matches(c));
 252         }
 253     }
 254
 255     /**
 256      * Test if URIs with percent encoded characters are all correctly serialized.
 257      */
 258     @Test
 259     public void serializePercentEncodingTest() {
 260         final String value = "foo" + ":foo bar/" + "foo,bar/" + "'bar'";
 261         final String encoded = "foo%3Afoo%20bar%2Ffoo%2Cbar%2F%27bar%27";
 262
 263         final YangInstanceIdentifier data = YangInstanceIdentifier.builder()
 264                 .node(QName.create("serializer:test", "2016-06-06", "list-one-key"))
 265                 .nodeWithKey(QName.create("serializer:test", "2016-06-06", "list-one-key"),
 266                         QName.create("serializer:test", "2016-06-06", "list-one-key"), value)
 267                 .build();
 268
 269         final String result = YangInstanceIdentifierSerializer.create(this.schemaContext, data);
 270         assertEquals("Serialization not successful", "serializer-test:list-one-key=" + encoded, result);
 271     }
 272
 273     /**
 274      * Test if URIs with no percent encoded characters are correctly serialized. Input should be untouched.
 275      */
 276     @Test
 277     public void serializeNoPercentEncodingTest() {
 278         final String value = "foo\"b\"bar";
 279
 280         final YangInstanceIdentifier data = YangInstanceIdentifier.builder()
 281                 .node(QName.create("serializer:test", "2016-06-06", "list-one-key"))
 282                 .nodeWithKey(QName.create("serializer:test", "2016-06-06", "list-one-key"),
 283                         QName.create("serializer:test", "2016-06-06", "list-one-key"), value)
 284                 .build();
 285
 286         final String result = YangInstanceIdentifierSerializer.create(this.schemaContext, data);
 287         assertEquals("Serialization not successful", "serializer-test:list-one-key=" + value, result);
 288     }
 289
 290     /**
 291      * Test of serialization when nodes in input <code>YangInstanceIdentifier</code> are defined in two different
 292      * modules by using augmentation.
 293      */
 294     @Test
 295     public void serializeIncludedNodesTest() {
 296         final QName list = QName.create("serializer:test:included", "2016-06-06", "augmented-list");
 297         final QName child = QName.create("serializer:test", "2016-06-06", "augmented-leaf");
 298
 299         final YangInstanceIdentifier data = YangInstanceIdentifier.builder()
 300                 .node(list)
 301                 .node(NodeIdentifierWithPredicates.of(list, QName.create(list, "list-key"), 100))
 302                 .node(new AugmentationIdentifier(ImmutableSet.of(child)))
 303                 .node(child)
 304                 .build();
 305
 306         final String result = YangInstanceIdentifierSerializer.create(this.schemaContext, data);
 307
 308         assertEquals("Serialization not successful",
 309                 "serializer-test-included:augmented-list=100/serializer-test:augmented-leaf", result);
 310     }
 311
 312     /**
 313      * Test of serialization when nodes in input <code>YangInstanceIdentifier</code> are defined in two different
 314      * modules by using augmentation. Augmented node in data supplied for serialization has wrong namespace.
 315      * <code>RestconfDocumentedException</code> is expected because augmented node is defined in other module than its
 316      * parent and will not be found.
 317      */
 318     @Test
 319     public void serializeIncludedNodesSerializationTest() {
 320         final QName list = QName.create("serializer:test:included", "2016-06-06", "augmented-list");
 321         // child should has different namespace
 322         final QName child = QName.create("serializer:test:included", "2016-06-06", "augmented-leaf");
 323
 324         final YangInstanceIdentifier data = YangInstanceIdentifier.builder()
 325                 .node(list)
 326                 .node(NodeIdentifierWithPredicates.of(list, QName.create(list, "list-key"), 100))
 327                 .node(new AugmentationIdentifier(ImmutableSet.of(child)))
 328                 .node(child)
 329                 .build();
 330
 331         this.thrown.expect(RestconfDocumentedException.class);
 332         YangInstanceIdentifierSerializer.create(this.schemaContext, data);
 333     }
 334 }