yang/yang-data-codec-gson/src/test/java/org/opendaylight/yangtools/yang/data/codec/gson/NormalizedNodeToJsonStreamTest.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.yangtools.yang.data.codec.gson;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertFalse;
  12 import static org.junit.Assert.assertNotNull;
  13 import static org.junit.Assert.assertNull;
  14 import static org.junit.Assert.assertTrue;
  15 import static org.opendaylight.yangtools.yang.data.codec.gson.TestUtils.childArray;
  16 import static org.opendaylight.yangtools.yang.data.codec.gson.TestUtils.childPrimitive;
  17 import static org.opendaylight.yangtools.yang.data.codec.gson.TestUtils.resolveCont1;
  18 import static org.opendaylight.yangtools.yang.data.codec.gson.TestUtils.resolveCont2;
  19
  20 import com.google.common.collect.ImmutableSet;
  21 import com.google.gson.JsonArray;
  22 import com.google.gson.JsonElement;
  23 import com.google.gson.JsonNull;
  24 import com.google.gson.JsonObject;
  25 import com.google.gson.JsonPrimitive;
  26 import java.io.IOException;
  27 import java.io.StringWriter;
  28 import java.io.Writer;
  29 import java.util.HashSet;
  30 import java.util.Iterator;
  31 import org.junit.Test;
  32 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  33 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
  34 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeWriter;
  35 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  36
  37 /**
  38  * Each test tests whether json output obtained after transformation contains is corect. The transformation takes
  39  * normalized node data structure and transform it to json output. To make it easier validate json output it is loaded
  40  * via gson as structure of json elements which are walked and compared with awaited values.
  41  */
  42 public class NormalizedNodeToJsonStreamTest extends AbstractComplexJsonTest {
  43     @Test
  44     public void leafNodeInContainer() throws IOException {
  45         final String jsonOutput = normalizedNodeToJsonStreamTransformation(
  46             TestingNormalizedNodeStructuresCreator.leafNodeInContainer());
  47         final JsonObject cont1 = resolveCont1(jsonOutput);
  48         assertNotNull(cont1);
  49
  50         final JsonPrimitive lf11 = childPrimitive(cont1, "complexjson:lf11", "lf11");
  51         assertNotNull(lf11);
  52         final int asInt = lf11.getAsInt();
  53         assertEquals(453, asInt);
  54     }
  55
  56     @Test
  57     public void leafListNodeInContainerMultiline() throws IOException {
  58         final String jsonOutput = normalizedNodeToJsonStreamTransformation(
  59             TestingNormalizedNodeStructuresCreator.leafListNodeInContainerMultiline());
  60         final JsonObject cont1 = resolveCont1(jsonOutput);
  61         assertNotNull(cont1);
  62         final JsonArray lflst11 = childArray(cont1, "complexjson:lflst11", "lflst11");
  63         assertNotNull(lflst11);
  64
  65         final HashSet<Object> lflst11Values = new HashSet<>();
  66         for (final JsonElement jsonElement : lflst11) {
  67             assertTrue(jsonElement instanceof JsonPrimitive);
  68             lflst11Values.add(jsonElement.getAsString());
  69         }
  70
  71         assertEquals(ImmutableSet.of("lflst11 value2\r\nanother line 2", "lflst11 value1\nanother line 1"),
  72             lflst11Values);
  73     }
  74
  75     @Test
  76     public void leafNodeViaAugmentationInContainer() throws IOException {
  77         final String jsonOutput = normalizedNodeToJsonStreamTransformation(
  78             TestingNormalizedNodeStructuresCreator.leafNodeViaAugmentationInContainer());
  79         final JsonObject cont1 = resolveCont1(jsonOutput);
  80         assertNotNull(cont1);
  81
  82         final JsonPrimitive lf12_1 = childPrimitive(cont1, "complexjson:lf12_1", "lf12_1");
  83         assertNotNull(lf12_1);
  84         final String asString = lf12_1.getAsString();
  85         assertEquals("lf12 value", asString);
  86     }
  87
  88     @Test
  89     public void leafListNodeInContainer() throws IOException {
  90         final String jsonOutput = normalizedNodeToJsonStreamTransformation(
  91             TestingNormalizedNodeStructuresCreator.leafListNodeInContainer());
  92         final JsonObject cont1 = resolveCont1(jsonOutput);
  93         assertNotNull(cont1);
  94         final JsonArray lflst11 = childArray(cont1, "complexjson:lflst11", "lflst11");
  95         assertNotNull(lflst11);
  96
  97         final HashSet<Object> lflst11Values = new HashSet<>();
  98         for (final JsonElement jsonElement : lflst11) {
  99             assertTrue(jsonElement instanceof JsonPrimitive);
 100             lflst11Values.add(jsonElement.getAsString());
 101         }
 102
 103         assertEquals(ImmutableSet.of("lflst11 value2", "lflst11 value1"), lflst11Values);
 104     }
 105
 106     @Test
 107     public void keyedListNodeInContainer() throws IOException {
 108         final String jsonOutput = normalizedNodeToJsonStreamTransformation(
 109             TestingNormalizedNodeStructuresCreator.keyedListNodeInContainer());
 110         final JsonObject cont1 = resolveCont1(jsonOutput);
 111         assertNotNull(cont1);
 112         final JsonArray lst11 = childArray(cont1, "complexjson:lst11", "lst11");
 113         assertNotNull(lst11);
 114
 115         final Iterator<JsonElement> iterator = lst11.iterator();
 116         assertTrue(iterator.hasNext());
 117         final JsonElement lst11Entry1Raw = iterator.next();
 118         assertFalse(iterator.hasNext());
 119         assertTrue(lst11Entry1Raw instanceof JsonObject);
 120         final JsonObject lst11Entry1 = (JsonObject) lst11Entry1Raw;
 121
 122         final JsonPrimitive key111 = childPrimitive(lst11Entry1, "complexjson:key111", "key111");
 123         assertNotNull(key111);
 124         final JsonPrimitive lf112 = childPrimitive(lst11Entry1, "complexjson:lf112", "lf112");
 125         assertNotNull(lf112);
 126         final JsonPrimitive lf113 = childPrimitive(lst11Entry1, "complexjson:lf113", "lf113");
 127         assertNotNull(lf113);
 128         final JsonPrimitive lf111 = childPrimitive(lst11Entry1, "complexjson:lf111", "lf111");
 129         assertNotNull(lf111);
 130
 131         assertEquals("key111 value", key111.getAsString());
 132         assertEquals("/complexjson:cont1/complexjson:lflst11[.='foo']", lf112.getAsString());
 133         assertEquals("lf113 value", lf113.getAsString());
 134         assertEquals("lf111 value", lf111.getAsString());
 135     }
 136
 137     @Test
 138     public void choiceNodeInContainer() throws IOException {
 139         final String jsonOutput = normalizedNodeToJsonStreamTransformation(
 140             TestingNormalizedNodeStructuresCreator.choiceNodeInContainer());
 141         final JsonObject cont1 = resolveCont1(jsonOutput);
 142         assertNotNull(cont1);
 143         final JsonPrimitive lf13 = childPrimitive(cont1, "complexjson:lf13", "lf13");
 144         assertNotNull(lf13);
 145
 146         assertEquals("lf13 value", lf13.getAsString());
 147     }
 148
 149     /**
 150      * tested case when case c11A in choice choc11 is augmented (two leaves (augment A) and one leaf (augment B) are
 151      * added).
 152      *
 153      * <p>
 154      * after running this test following exception is raised:
 155      * java.lang.IllegalArgumentException: Augmentation allowed only in DataNodeContainer
 156      * [ChoiceNodeImpl[qname=(ns:complex:json?revision=2014-08-11)choc11]]
 157      */
 158     @Test
 159     public void caseNodeAugmentationInChoiceInContainer() throws IOException {
 160         final String jsonOutput = normalizedNodeToJsonStreamTransformation(
 161             TestingNormalizedNodeStructuresCreator.caseNodeAugmentationInChoiceInContainer());
 162         final JsonObject cont1 = resolveCont1(jsonOutput);
 163         assertNotNull(cont1);
 164
 165         final JsonPrimitive lf15_21 = childPrimitive(cont1, "complexjson:lf15_21", "lf15_21");
 166         assertNotNull(lf15_21);
 167         final JsonPrimitive lf13 = childPrimitive(cont1, "complexjson:lf13", "lf13");
 168         assertNotNull(lf13);
 169         final JsonPrimitive lf15_11 = childPrimitive(cont1, "complexjson:lf15_11", "lf15_11");
 170         assertNotNull(lf15_11);
 171         final JsonPrimitive lf15_12 = childPrimitive(cont1, "complexjson:lf15_12", "lf15_12");
 172         assertNotNull(lf15_12);
 173
 174         assertEquals("lf15_21 value", lf15_21.getAsString());
 175         assertEquals("lf13 value", lf13.getAsString());
 176         assertTrue("one two".equals(lf15_11.getAsString()) || "two one".equals(lf15_11.getAsString()));
 177         assertEquals("complexjson:ident", lf15_12.getAsString());
 178     }
 179
 180     /**
 181      * tested case when case c11A in choice choc11 is augmented (two leaves (augment A) internally and one two leaves
 182      * with the same names externally (augment B) are added).
 183      *
 184      * <p>
 185      * after running this test following exception is raised:
 186      * java.lang.IllegalArgumentException: Augmentation allowed only in DataNodeContainer
 187      * [ChoiceNodeImpl[qname=(ns:complex:json?revision=2014-08-11)choc11]]
 188      */
 189     @Test
 190     public void caseNodeExternalAugmentationInChoiceInContainer() throws IOException {
 191         final String jsonOutput = normalizedNodeToJsonStreamTransformation(
 192             TestingNormalizedNodeStructuresCreator.caseNodeExternalAugmentationInChoiceInContainer());
 193         final JsonObject cont1 = resolveCont1(jsonOutput);
 194         assertNotNull(cont1);
 195
 196         final JsonPrimitive lf15_11Augment = childPrimitive(cont1, "complexjson-augmentation:lf15_11");
 197         assertNotNull(lf15_11Augment);
 198         final JsonPrimitive lf15_12Augment = childPrimitive(cont1, "complexjson-augmentation:lf15_12");
 199         assertNotNull(lf15_12Augment);
 200         final JsonPrimitive lf13 = childPrimitive(cont1, "complexjson:lf13", "lf13");
 201         assertNotNull(lf13);
 202         final JsonPrimitive lf15_11 = childPrimitive(cont1, "complexjson:lf15_11", "lf15_11");
 203         assertNotNull(lf15_11);
 204         final JsonPrimitive lf15_12 = childPrimitive(cont1, "complexjson:lf15_12", "lf15_12");
 205         assertNotNull(lf15_12);
 206
 207         assertEquals("lf15_11 value from augmentation", lf15_11Augment.getAsString());
 208         assertEquals("lf15_12 value from augmentation", lf15_12Augment.getAsString());
 209         assertEquals("lf13 value", lf13.getAsString());
 210         assertTrue("one two".equals(lf15_11.getAsString()) || "two one".equals(lf15_11.getAsString()));
 211         assertEquals("complexjson:ident", lf15_12.getAsString());
 212     }
 213
 214     /**
 215      * augmentation of choice - adding new case.
 216      *
 217      * <p>
 218      * after running this test following exception is raised:
 219      * java.lang.IllegalArgumentException: Augmentation allowed only in DataNodeContainer
 220      * [ChoiceNodeImpl[qname=(ns:complex:json?revision=2014-08-11)choc11]]
 221      */
 222     @Test
 223     public void choiceNodeAugmentationInContainer() throws IOException {
 224         final String jsonOutput = normalizedNodeToJsonStreamTransformation(
 225             TestingNormalizedNodeStructuresCreator.choiceNodeAugmentationInContainer());
 226         final JsonObject cont1 = resolveCont1(jsonOutput);
 227         assertNotNull(cont1);
 228
 229         final JsonPrimitive lf17 = childPrimitive(cont1, "complexjson:lf17", "lf17");
 230         assertNotNull(lf17);
 231         assertEquals("lf17 value", lf17.getAsString());
 232     }
 233
 234     @Test
 235     public void unkeyedNodeInContainer() throws IOException {
 236         final String jsonOutput = normalizedNodeToJsonStreamTransformation(
 237             TestingNormalizedNodeStructuresCreator.unkeyedNodeInContainer());
 238         final JsonObject cont1 = resolveCont1(jsonOutput);
 239         assertNotNull(cont1);
 240
 241         final JsonArray lst12 = childArray(cont1, "complexjson:lst12", "lst12");
 242         assertNotNull(lst12);
 243
 244         final Iterator<JsonElement> iterator = lst12.iterator();
 245         assertTrue(iterator.hasNext());
 246         final JsonElement lst12Entry1Raw = iterator.next();
 247         assertFalse(iterator.hasNext());
 248
 249         assertTrue(lst12Entry1Raw instanceof JsonObject);
 250         final JsonObject lst12Entry1 = (JsonObject) lst12Entry1Raw;
 251         final JsonPrimitive lf121 = childPrimitive(lst12Entry1, "complexjson:lf121", "lf121");
 252         assertNotNull(lf121);
 253
 254         assertEquals("lf121 value", lf121.getAsString());
 255     }
 256
 257     @Test
 258     public void emptyTypeTest() throws IOException {
 259         final String jsonOutput = normalizedNodeToJsonStreamTransformation(CONT1_WITH_EMPTYLEAF);
 260         final JsonObject cont1 = resolveCont1(jsonOutput);
 261         final JsonElement emptyObj = cont1.get("empty");
 262         assertNotNull(emptyObj);
 263         assertTrue(emptyObj instanceof JsonArray);
 264         assertEquals(1, emptyObj.getAsJsonArray().size());
 265         assertTrue(emptyObj.getAsJsonArray().get(0) instanceof JsonNull);
 266     }
 267
 268     @Test
 269     public void emptyNonPresenceContainerTest() throws IOException {
 270         final String jsonOutput = normalizedNodeToJsonStreamTransformation(
 271             TestingNormalizedNodeStructuresCreator.topLevelContainer());
 272         final JsonObject cont1 = resolveCont1(jsonOutput);
 273         assertNull(cont1);
 274     }
 275
 276     @Test
 277     public void emptyNonPresenceContainerInContainerTest() throws IOException {
 278         final String jsonOutput = normalizedNodeToJsonStreamTransformation(
 279             TestingNormalizedNodeStructuresCreator.emptyContainerInContainer());
 280         final JsonObject cont1 = resolveCont1(jsonOutput);
 281         assertNull(cont1);
 282     }
 283
 284     @Test
 285     public void emptyPresenceContainerTest() throws IOException {
 286         final String jsonOutput = normalizedNodeToJsonStreamTransformation(
 287             TestingNormalizedNodeStructuresCreator.cont2Node());
 288         final JsonObject cont2 = resolveCont2(jsonOutput);
 289         assertNotNull(cont2);
 290     }
 291
 292     private static String normalizedNodeToJsonStreamTransformation(final NormalizedNode inputStructure)
 293             throws IOException {
 294         final Writer writer = new StringWriter();
 295         final NormalizedNodeStreamWriter jsonStream = JSONNormalizedNodeStreamWriter.createExclusiveWriter(
 296             lhotkaCodecFactory, SchemaPath.ROOT, null, JsonWriterFactory.createJsonWriter(writer, 2));
 297         try (NormalizedNodeWriter nodeWriter = NormalizedNodeWriter.forStreamWriter(jsonStream)) {
 298             nodeWriter.write(inputStructure);
 299         }
 300
 301         return writer.toString();
 302     }
 303 }