opendaylight/md-sal/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/cnsn/to/json/test/CnSnToJsonBasicDataTypesTest.java

   1 package org.opendaylight.controller.sal.restconf.impl.cnsn.to.json.test;
   2
   3 import static org.junit.Assert.*;
   4
   5 import java.io.IOException;
   6 import java.io.StringReader;
   7 import java.math.BigDecimal;
   8 import java.net.URI;
   9 import java.net.URISyntaxException;
  10 import java.util.*;
  11
  12 import javax.ws.rs.WebApplicationException;
  13 import javax.xml.bind.DatatypeConverter;
  14
  15 import org.junit.BeforeClass;
  16 import org.junit.Test;
  17 import org.opendaylight.controller.sal.rest.impl.StructuredDataToJsonProvider;
  18 import org.opendaylight.controller.sal.restconf.impl.test.TestUtils;
  19 import org.opendaylight.controller.sal.restconf.impl.test.YangAndXmlAndDataSchemaLoader;
  20 import org.opendaylight.yangtools.yang.common.QName;
  21 import org.opendaylight.yangtools.yang.data.api.*;
  22 import org.opendaylight.yangtools.yang.data.impl.NodeFactory;
  23
  24 import com.google.gson.stream.JsonReader;
  25 import com.google.gson.stream.JsonToken;
  26
  27 public class CnSnToJsonBasicDataTypesTest extends YangAndXmlAndDataSchemaLoader {
  28
  29     @BeforeClass
  30     public static void initialize() {
  31         dataLoad("/cnsn-to-json/simple-data-types");
  32     }
  33
  34     @Test
  35     public void simpleYangDataTest() {
  36
  37         CompositeNode compositeNode = TestUtils.loadCompositeNode("/cnsn-to-json/simple-data-types/xml/data.xml");
  38
  39         String jsonOutput = null;
  40
  41         TestUtils.normalizeCompositeNode(compositeNode, modules, "simple-data-types:cont");
  42
  43         try {
  44             jsonOutput = TestUtils.writeCompNodeWithSchemaContextToOutput(compositeNode, modules, dataSchemaNode,
  45                     StructuredDataToJsonProvider.INSTANCE);
  46         } catch (WebApplicationException | IOException e) {
  47         }
  48         assertNotNull(jsonOutput);
  49
  50         verifyJsonOutput(jsonOutput);
  51     }
  52
  53     private CompositeNode prepareData() {
  54         MutableCompositeNode cont = NodeFactory.createMutableCompositeNode(TestUtils.buildQName("cont"), null, null,
  55                 ModifyAction.CREATE, null);
  56
  57         List<Node<?>> childNodes = new ArrayList<>();
  58         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfnint8Min"), cont, (byte) -128,
  59                 ModifyAction.CREATE, null));
  60         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfnint8Max"), cont, (byte) 127,
  61                 ModifyAction.CREATE, null));
  62         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfnint16Min"), cont, (short) -32768,
  63                 ModifyAction.CREATE, null));
  64         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfnint16Max"), cont, (short) 32767,
  65                 ModifyAction.CREATE, null));
  66         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfnint32Min"), cont,
  67                 (int) -2147483648, ModifyAction.CREATE, null));
  68         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfnint32Max"), cont, (int) 2147483647,
  69                 ModifyAction.CREATE, null));
  70         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfnint64Min"), cont, new Long(
  71                 "-9223372036854775807"), ModifyAction.CREATE, null));
  72         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfnint64Max"), cont, new Long(
  73                 "9223372036854775807"), ModifyAction.CREATE, null));
  74         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfnuint8Max"), cont, (short) 255,
  75                 ModifyAction.CREATE, null));
  76         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfnuint16Max"), cont, (int) 65535,
  77                 ModifyAction.CREATE, null));
  78         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfnuint32Max"), cont, new Long(
  79                 "4294967295"), ModifyAction.CREATE, null));
  80         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfstr"), cont, "lfstr",
  81                 ModifyAction.CREATE, null));
  82         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfstr1"), cont, "",
  83                 ModifyAction.CREATE, null));
  84         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfbool1"), cont, Boolean.TRUE,
  85                 ModifyAction.CREATE, null));
  86         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfbool2"), cont, Boolean.FALSE,
  87                 ModifyAction.CREATE, null));
  88         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfdecimal1"), cont, new BigDecimal(
  89                 "43.32"), ModifyAction.CREATE, null));
  90         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfdecimal2"), cont, new BigDecimal(
  91                 "-0.43"), ModifyAction.CREATE, null));
  92         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfdecimal3"), cont, new BigDecimal(
  93                 "43"), ModifyAction.CREATE, null));
  94         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfdecimal4"), cont, new BigDecimal(
  95                 "43E3"), ModifyAction.CREATE, null));
  96         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfdecimal6"), cont, new BigDecimal(
  97                 "33.12345"), ModifyAction.CREATE, null));
  98         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfenum"), cont, "enum3",
  99                 ModifyAction.CREATE, null));
 100
 101         HashSet<String> bits = new HashSet<String>();
 102         bits.add("bit3");
 103         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfbits"), cont, bits,
 104                 ModifyAction.CREATE, null));
 105
 106         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfbinary"), cont, DatatypeConverter
 107                 .parseBase64Binary("AAaacdabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"),
 108                 ModifyAction.CREATE, null));
 109         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfempty"), cont, null,
 110                 ModifyAction.CREATE, null));
 111         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfunion1"), cont, (int) 324,
 112                 ModifyAction.CREATE, null));
 113         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfunion2"), cont, new BigDecimal(
 114                 "33.3"), ModifyAction.CREATE, null));
 115         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfunion3"), cont, "55",
 116                 ModifyAction.CREATE, null));
 117         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfunion4"), cont, Boolean.TRUE,
 118                 ModifyAction.CREATE, null));
 119         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfunion5"), cont, "true",
 120                 ModifyAction.CREATE, null));
 121         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfunion6"), cont, "false",
 122                 ModifyAction.CREATE, null));
 123         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfunion7"), cont, null,
 124                 ModifyAction.CREATE, null));
 125         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfunion8"), cont, "",
 126                 ModifyAction.CREATE, null));
 127         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfunion9"), cont, "",
 128                 ModifyAction.CREATE, null));
 129
 130         HashSet<String> bits2 = new HashSet<String>();
 131         bits2.add("bt1");
 132         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfunion10"), cont, bits2,
 133                 ModifyAction.CREATE, null));
 134
 135         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfunion11"), cont, (short) 33,
 136                 ModifyAction.CREATE, null));
 137         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfunion12"), cont, Boolean.FALSE,
 138                 ModifyAction.CREATE, null));
 139         try {
 140             childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("identityref1"), cont, new QName(
 141                     new URI("simple:data:types"), "iden"), ModifyAction.CREATE, null));
 142         } catch (URISyntaxException e) {
 143         }
 144
 145         cont.getChildren().addAll(childNodes);
 146
 147         cont.init();
 148
 149         return cont;
 150     }
 151
 152     private void verifyJsonOutput(String jsonOutput) {
 153         StringReader strReader = new StringReader(jsonOutput);
 154         JsonReader jReader = new JsonReader(strReader);
 155
 156         String exception = null;
 157         try {
 158             jsonReadCont(jReader);
 159         } catch (IOException e) {
 160             exception = e.getMessage();
 161         }
 162
 163         assertNull("Error during reading Json output: " + exception, exception);
 164     }
 165
 166     private void jsonReadCont(JsonReader jReader) throws IOException {
 167         jReader.beginObject();
 168         assertNotNull("cont1 is missing.", jReader.hasNext());
 169
 170         // Cont dataFromJson = new Cont(jReader.nextName());
 171         jReader.nextName();
 172         jsonReadContElements(jReader);
 173
 174         assertFalse("cont shouldn't have other element.", jReader.hasNext());
 175         jReader.endObject();
 176         // return dataFromJson;
 177     }
 178
 179     private void jsonReadContElements(JsonReader jReader) throws IOException {
 180         jReader.beginObject();
 181         List<String> loadedLfs = new ArrayList<>();
 182         boolean exceptForDecimal5Raised = false;
 183         boolean enumChecked = false;
 184         boolean bitsChecked = false;
 185         boolean lfdecimal6Checked = false;
 186         boolean lfdecimal4Checked = false;
 187         boolean lfdecimal3Checked = false;
 188         boolean lfdecimal2Checked = false;
 189         boolean lfdecimal1Checked = false;
 190         boolean lfbool1Checked = false;
 191         boolean lfbool2Checked = false;
 192         boolean lfstrChecked = false;
 193         boolean lfbinaryChecked = false;
 194         // boolean lfref1Checked = false;
 195         boolean lfemptyChecked = false;
 196         boolean lfstr1Checked = false;
 197         boolean lfidentityrefChecked = false;
 198
 199         while (jReader.hasNext()) {
 200             String keyName = jReader.nextName();
 201             JsonToken peek = null;
 202             try {
 203                 peek = jReader.peek();
 204             } catch (IOException e) {
 205                 if (keyName.equals("lfdecimal5")) {
 206                     exceptForDecimal5Raised = true;
 207                 } else {
 208                     assertTrue("Key " + keyName + " has incorrect value for specifed type", false);
 209                 }
 210             }
 211
 212             if (keyName.startsWith("lfnint") || keyName.startsWith("lfnuint")) {
 213                 assertEquals("Key " + keyName + " has incorrect type", JsonToken.NUMBER, peek);
 214                 try {
 215                     jReader.nextLong();
 216                 } catch (NumberFormatException e) {
 217                     assertTrue("Key " + keyName + " has incorrect value - " + e.getMessage(), false);
 218                 }
 219                 loadedLfs.add(keyName.substring(3));
 220             } else if (keyName.equals("identityref1")) {
 221                 assertEquals("Key " + keyName + " has incorrect type", JsonToken.STRING, peek);
 222                 assertEquals("simple-data-types:iden", jReader.nextString());
 223                 lfidentityrefChecked = true;
 224             } else if (keyName.equals("lfstr")) {
 225                 assertEquals("Key " + keyName + " has incorrect type", JsonToken.STRING, peek);
 226                 assertEquals("lfstr", jReader.nextString());
 227                 lfstrChecked = true;
 228             } else if (keyName.equals("lfstr1")) {
 229                 assertEquals("Key " + keyName + " has incorrect type", JsonToken.STRING, peek);
 230                 assertEquals("", jReader.nextString());
 231                 lfstr1Checked = true;
 232             } else if (keyName.equals("lfbool1")) {
 233                 assertEquals("Key " + keyName + " has incorrect type", JsonToken.BOOLEAN, peek);
 234                 assertEquals(true, jReader.nextBoolean());
 235                 lfbool1Checked = true;
 236             } else if (keyName.equals("lfbool2")) {
 237                 assertEquals("Key " + keyName + " has incorrect type", JsonToken.BOOLEAN, peek);
 238                 assertEquals(false, jReader.nextBoolean());
 239                 lfbool2Checked = true;
 240             } else if (keyName.equals("lfbool3")) {
 241                 assertEquals("Key " + keyName + " has incorrect type", JsonToken.BOOLEAN, peek);
 242                 assertEquals(false, jReader.nextBoolean());
 243             } else if (keyName.equals("lfdecimal1")) {
 244                 assertEquals("Key " + keyName + " has incorrect type", JsonToken.NUMBER, peek);
 245                 assertEquals(new Double(43.32), (Double) jReader.nextDouble());
 246                 lfdecimal1Checked = true;
 247             } else if (keyName.equals("lfdecimal2")) {
 248                 assertEquals("Key " + keyName + " has incorrect type", JsonToken.NUMBER, peek);
 249                 assertEquals(new Double(-0.43), (Double) jReader.nextDouble());
 250                 lfdecimal2Checked = true;
 251             } else if (keyName.equals("lfdecimal3")) {
 252                 assertEquals("Key " + keyName + " has incorrect type", JsonToken.NUMBER, peek);
 253                 assertEquals(new Double(43), (Double) jReader.nextDouble());
 254                 lfdecimal3Checked = true;
 255             } else if (keyName.equals("lfdecimal4")) {
 256                 assertEquals("Key " + keyName + " has incorrect type", JsonToken.NUMBER, peek);
 257                 assertEquals(new Double(43E3), (Double) jReader.nextDouble());
 258                 lfdecimal4Checked = true;
 259             } else if (keyName.equals("lfdecimal6")) {
 260                 assertEquals("Key " + keyName + " has incorrect type", JsonToken.NUMBER, peek);
 261                 assertEquals(new Double(33.12345), (Double) jReader.nextDouble());
 262                 lfdecimal6Checked = true;
 263             } else if (keyName.equals("lfenum")) {
 264                 assertEquals("enum3", jReader.nextString());
 265                 enumChecked = true;
 266             } else if (keyName.equals("lfbits")) {
 267                 assertEquals("bit3 bit2", jReader.nextString());
 268                 bitsChecked = true;
 269             } else if (keyName.equals("lfbinary")) {
 270                 assertEquals("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", jReader.nextString());
 271                 lfbinaryChecked = true;
 272             } else if (keyName.equals("lfempty")) {
 273                 jReader.beginArray();
 274                 jReader.nextNull();
 275                 jReader.endArray();
 276                 lfemptyChecked = true;
 277             } else if (keyName.startsWith("lfunion")) {
 278                 checkLfUnion(jReader, keyName, peek);
 279             } else {
 280                 assertTrue("Key " + keyName + " doesn't exists in yang file.", false);
 281             }
 282
 283         }
 284         Collections.sort(loadedLfs);
 285         String expectedLfsStr = "[int16Max, int16Min, int32Max, int32Min, int64Max, int64Min, int8Max, int8Min, uint16Max, uint32Max, uint8Max]";
 286         String actualLfsStr = loadedLfs.toString();
 287         assertEquals("Some leaves are missing", expectedLfsStr, actualLfsStr);
 288         assertTrue("Enum wasn't checked", enumChecked);
 289         assertTrue("Bits wasn't checked", bitsChecked);
 290         assertTrue("Decimal1 wasn't checked", lfdecimal1Checked);
 291         assertTrue("Decimal2 wasn't checked", lfdecimal2Checked);
 292         assertTrue("Decimal3 wasn't checked", lfdecimal3Checked);
 293         assertTrue("Decimal4 wasn't checked", lfdecimal4Checked);
 294         assertTrue("Decimal5 wasn't checked", lfdecimal6Checked);
 295         assertTrue("lfbool1 wasn't checked", lfbool1Checked);
 296         assertTrue("lfbool2 wasn't checked", lfbool2Checked);
 297         assertTrue("lfstr wasn't checked", lfstrChecked);
 298         assertTrue("lfstr1 wasn't checked", lfstr1Checked);
 299         assertTrue("lfbinary wasn't checked", lfbinaryChecked);
 300         assertTrue("lfempty wasn't checked", lfemptyChecked);
 301         assertTrue("lfidentityref wasn't checked", lfidentityrefChecked);
 302         jReader.endObject();
 303     }
 304
 305     private void checkLfUnion(JsonReader jReader, String keyName, JsonToken peek) throws IOException {
 306         if (keyName.equals("lfunion1")) {
 307             assertEquals("Key " + keyName + " has incorrect type", JsonToken.STRING, peek);
 308             assertEquals("324", jReader.nextString());
 309         } else if (keyName.equals("lfunion2")) {
 310             assertEquals("Key " + keyName + " has incorrect type", JsonToken.STRING, peek);
 311             assertEquals("33.3", jReader.nextString());
 312         } else if (keyName.equals("lfunion3")) {
 313             assertEquals("Key " + keyName + " has incorrect type", JsonToken.STRING, peek);
 314             assertEquals("55", jReader.nextString());
 315         } else if (keyName.equals("lfunion4")) {
 316             assertEquals("Key " + keyName + " has incorrect type", JsonToken.STRING, peek);
 317             assertEquals("true", jReader.nextString());
 318         } else if (keyName.equals("lfunion5")) {
 319             assertEquals("Key " + keyName + " has incorrect type", JsonToken.STRING, peek);
 320             assertEquals("true", jReader.nextString());
 321         } else if (keyName.equals("lfunion6")) {
 322             assertEquals("Key " + keyName + " has incorrect type", JsonToken.STRING, peek);
 323             assertEquals("false", jReader.nextString());
 324         } else if (keyName.equals("lfunion7")) {
 325             assertEquals("Key " + keyName + " has incorrect type", JsonToken.STRING, peek);
 326             assertEquals("", jReader.nextString());
 327         } else if (keyName.equals("lfunion8")) {
 328             assertEquals("Key " + keyName + " has incorrect type", JsonToken.STRING, peek);
 329             assertEquals("", jReader.nextString());
 330         } else if (keyName.equals("lfunion9")) {
 331             assertEquals("Key " + keyName + " has incorrect type", JsonToken.STRING, peek);
 332             assertEquals("", jReader.nextString());
 333         } else if (keyName.equals("lfunion10")) {
 334             assertEquals("Key " + keyName + " has incorrect type", JsonToken.STRING, peek);
 335             assertEquals("bt1", jReader.nextString());
 336         } else if (keyName.equals("lfunion11")) {
 337             assertEquals("Key " + keyName + " has incorrect type", JsonToken.STRING, peek);
 338             assertEquals("33", jReader.nextString());
 339         } else if (keyName.equals("lfunion12")) {
 340             assertEquals("Key " + keyName + " has incorrect type", JsonToken.STRING, peek);
 341             assertEquals("false", jReader.nextString());
 342         } else if (keyName.equals("lfunion13")) {
 343             assertEquals("Key " + keyName + " has incorrect type", JsonToken.STRING, peek);
 344             assertEquals("44", jReader.nextString());
 345         } else if (keyName.equals("lfunion14")) {
 346             assertEquals("Key " + keyName + " has incorrect type", JsonToken.STRING, peek);
 347             assertEquals("21", jReader.nextString());
 348         }
 349     }
 350 }