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
   9 package org.opendaylight.restconf.nb.rfc8040.utils.parser;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.junit.Assert.assertTrue;
  13
  14 import com.google.common.collect.Sets;
  15 import java.util.HashMap;
  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.restconf.common.errors.RestconfDocumentedException;
  23 import org.opendaylight.restconf.nb.rfc8040.TestRestconfUtils;
  24 import org.opendaylight.restconf.nb.rfc8040.utils.parser.builder.ParserBuilderConstants;
  25 import org.opendaylight.yangtools.yang.common.QName;
  26 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  27 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
  28 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  29 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
  30
  31 /**
  32  * Unit tests for {@link YangInstanceIdentifierSerializer}.
  33  */
  34 public class YangInstanceIdentifierSerializerTest {
  35
  36     @Rule
  37     public ExpectedException thrown = ExpectedException.none();
  38
  39     // schema context with test modules
  40     private SchemaContext schemaContext;
  41
  42     @Before
  43     public void init() throws Exception {
  44         this.schemaContext =
  45                 YangParserTestUtils.parseYangFiles(TestRestconfUtils.loadFiles("/restconf/parser/serializer"));
  46     }
  47
  48     /**
  49      * Positive test of serialization of <code>YangInstanceIdentifier</code> containing container node to
  50      * <code>String</code>. Returned <code>String</code> is compared to have expected value.
  51      */
  52     @Test
  53     public void serializeContainerTest() {
  54         final YangInstanceIdentifier data = YangInstanceIdentifier.builder()
  55                 .node(QName.create("serializer:test", "2016-06-06", "contA"))
  56                 .build();
  57
  58         final String result = YangInstanceIdentifierSerializer.create(this.schemaContext, data);
  59         assertEquals("Serialization not successful",
  60                 "serializer-test:contA", result);
  61     }
  62
  63     /**
  64      * Positive test of serialization of <code>YangInstanceIdentifier</code> containing container with leaf node to
  65      * <code>String</code>. Returned <code>String</code> is compared to have expected value.
  66      */
  67     @Test
  68     public void serializeContainerWithLeafTest() {
  69         final YangInstanceIdentifier data = YangInstanceIdentifier.builder()
  70                 .node(QName.create("serializer:test", "2016-06-06", "contA"))
  71                 .node(QName.create("serializer:test", "2016-06-06", "leaf-A"))
  72                 .build();
  73
  74         final String result = YangInstanceIdentifierSerializer.create(this.schemaContext, data);
  75         assertEquals("Serialization not successful", "serializer-test:contA/leaf-A", result);
  76     }
  77
  78     /**
  79      * Positive test of serialization of <code>YangInstanceIdentifier</code> containing container with list with leaf
  80      * list node to <code>String</code>. Returned <code>String</code> is compared to have expected value.
  81      */
  82     @Test
  83     public void serializeContainerWithListWithLeafListTest() {
  84         final QName list = QName.create("serializer:test", "2016-06-06", "list-A");
  85         final QName leafList = QName.create("serializer:test", "2016-06-06", "leaf-list-AA");
  86
  87         final YangInstanceIdentifier data = YangInstanceIdentifier.builder()
  88                 .node(QName.create("serializer:test", "2016-06-06", "contA"))
  89                 .node(list)
  90                 .node(new YangInstanceIdentifier.NodeIdentifierWithPredicates(
  91                         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, 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         this.thrown.expect(RestconfDocumentedException.class);
 231         YangInstanceIdentifierSerializer.create(this.schemaContext, 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                     ParserBuilderConstants.Serializer.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                     ParserBuilderConstants.Serializer.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(this.schemaContext, 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(this.schemaContext, 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(new YangInstanceIdentifier.NodeIdentifierWithPredicates(
 301                         list, QName.create(list, "list-key"), 100))
 302                 .node(new YangInstanceIdentifier.AugmentationIdentifier(Sets.newHashSet(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(new YangInstanceIdentifier.NodeIdentifierWithPredicates(
 327                         list, QName.create(list, "list-key"), 100))
 328                 .node(new YangInstanceIdentifier.AugmentationIdentifier(Sets.newHashSet(child)))
 329                 .node(child)
 330                 .build();
 331
 332         this.thrown.expect(RestconfDocumentedException.class);
 333         YangInstanceIdentifierSerializer.create(this.schemaContext, data);
 334     }
 335 }