aai-schema-abstraction/src/test/java/org/onap/aai/schemaif/json/JsonSchemaProviderTest.java

   1 /**
   2  * ============LICENSE_START=======================================================
   3  * org.onap.aai
   4  * ================================================================================
   5  * Copyright © 2019 AT&T Intellectual Property. All rights reserved.
   6  * Copyright © 2019 Amdocs
   7  * ================================================================================
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *       http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  * ============LICENSE_END=========================================================
  20  */
  21
  22 package org.onap.aai.schemaif.json;
  23
  24 import static org.junit.Assert.assertEquals;
  25 import static org.junit.Assert.assertFalse;
  26 import static org.junit.Assert.assertNotNull;
  27 import static org.junit.Assert.assertNull;
  28 import static org.junit.Assert.assertTrue;
  29 import static org.junit.Assert.fail;
  30
  31 import java.io.ByteArrayOutputStream;
  32 import java.io.IOException;
  33 import java.io.PrintWriter;
  34 import java.io.StringWriter;
  35 import java.nio.file.Files;
  36 import java.nio.file.Paths;
  37 import java.util.List;
  38 import java.util.Set;
  39 import java.util.zip.ZipEntry;
  40 import java.util.zip.ZipOutputStream;
  41
  42 import org.junit.Before;
  43 import org.junit.Test;
  44 import org.onap.aai.schemaif.SchemaProviderException;
  45 import org.onap.aai.schemaif.definitions.EdgeSchema;
  46 import org.onap.aai.schemaif.definitions.PropertySchema;
  47 import org.onap.aai.schemaif.definitions.VertexSchema;
  48 import org.onap.aai.schemaif.definitions.types.ComplexDataType;
  49 import org.onap.aai.schemaif.definitions.types.DataType.Type;
  50 import org.onap.aai.schemaif.definitions.types.ListDataType;
  51 import org.onap.aai.schemaif.definitions.types.MapDataType;
  52 import org.onap.aai.schemaif.json.definitions.DataTypeDefinition;
  53 import org.onap.aai.schemaif.json.definitions.JsonEdgeSchema;
  54 import org.onap.aai.schemaif.json.definitions.JsonPropertySchema;
  55 import org.onap.aai.schemaif.json.definitions.JsonSchema;
  56 import org.onap.aai.schemaif.json.definitions.JsonVertexSchema;
  57
  58 public class JsonSchemaProviderTest {
  59
  60     JsonSchemaProviderConfig config = new JsonSchemaProviderConfig();
  61
  62     @Before
  63     public void init() {
  64         config.setSchemaServiceBaseUrl("https://testurl.com:8443");
  65         config.setSchemaServiceCertFile("/c/certfile");
  66         config.setSchemaServiceCertPwd("my-password");
  67         config.setServiceName("test-service");
  68     }
  69
  70     @Test
  71     public void testReadZipJson() throws IOException, SchemaProviderException {
  72         JsonSchemaProvider jsonSchemaProvider = new JsonSchemaProvider(config);
  73
  74         ByteArrayOutputStream fos = new ByteArrayOutputStream();
  75         ZipOutputStream zos = new ZipOutputStream(fos);
  76         zos.putNextEntry(new ZipEntry("schemaServiceResponse.json"));
  77         byte[] fileData = Files.readAllBytes(Paths.get("src/test/resources/json/schemaServiceResponse.json"));
  78         zos.write(fileData, 0, fileData.length);
  79         zos.closeEntry();
  80         zos.close();
  81
  82         String testSchema = readFile("src/test/resources/json/schemaServiceResponse.json");
  83         SchemaServiceResponse resp = SchemaServiceResponse.fromJson(testSchema);
  84
  85         String result = jsonSchemaProvider.unzipAndGetJSONString(fos.toByteArray());
  86         SchemaServiceResponse resp2 = SchemaServiceResponse.fromJson(result);
  87         assertEquals(resp.toJson(), resp2.toJson());
  88     }
  89
  90     @Test
  91     public void testJsonSchemaLoad() {
  92         try {
  93             String testSchema = readFile("src/test/resources/json/jsonSchema.json");
  94             JsonSchema jsonSchema = JsonSchema.fromJson(testSchema);
  95
  96             // Test Edge Schema
  97             JsonEdgeSchema edgeSchema = null;
  98             for (JsonEdgeSchema edge : jsonSchema.getRelationshipTypes()) {
  99                 if ((edge.getFrom().equals("onap.nodes.sdwan.uCPE"))
 100                         && (edge.getTo().equals("onap.nodes.sdwan.service.SubscriberService"))) {
 101                     edgeSchema = edge;
 102                     break;
 103                 }
 104             }
 105
 106             assertNotNull(edgeSchema);
 107             assertEquals("onap.relationships.sdwan.BelongsTo", edgeSchema.getLabel());
 108
 109             // Test Node Schema
 110             JsonVertexSchema vertexSchema = null;
 111             for (JsonVertexSchema v : jsonSchema.getNodeTypes()) {
 112                 if ((v.getName().equals("org.onap.resource.NetworkRules"))) {
 113                     vertexSchema = v;
 114                     break;
 115                 }
 116             }
 117
 118             assertNotNull(vertexSchema);
 119             assertEquals(2, vertexSchema.getProperties().size());
 120
 121             JsonPropertySchema propSchema = null;
 122             for (JsonPropertySchema p : vertexSchema.getProperties()) {
 123                 if ((p.getName().equals("network_policy_entries"))) {
 124                     propSchema = p;
 125                     break;
 126                 }
 127             }
 128
 129             assertNotNull(propSchema);
 130             assertEquals(false, propSchema.getRequired());
 131             assertEquals(false, propSchema.getUnique());
 132             assertEquals("org.onap.datatypes.RuleList", propSchema.getDataType());
 133             assertEquals("", propSchema.getDefaultValue());
 134             assertEquals(4, propSchema.getAnnotations().size());
 135
 136             // Test DataType Schema
 137             DataTypeDefinition dataType = null;
 138             for (DataTypeDefinition d : jsonSchema.getDataTypes()) {
 139                 if ((d.getName().equals("org.onap.datatypes.network.VlanRequirements"))) {
 140                     dataType = d;
 141                     break;
 142                 }
 143             }
 144
 145             assertNotNull(dataType);
 146             assertEquals("org.onap.datatypes.network.VlanRequirements", dataType.getName());
 147             assertEquals(4, dataType.getProperties().size());
 148
 149             propSchema = null;
 150             for (JsonPropertySchema p : dataType.getProperties()) {
 151                 if ((p.getName().equals("vlan_type"))) {
 152                     propSchema = p;
 153                     break;
 154                 }
 155             }
 156
 157             assertNotNull(propSchema);
 158             assertEquals(false, propSchema.getRequired());
 159             assertEquals("string", propSchema.getDataType());
 160             assertEquals("", propSchema.getDefaultValue());
 161         } catch (Exception ex) {
 162             StringWriter writer = new StringWriter();
 163             PrintWriter printWriter = new PrintWriter(writer);
 164             ex.printStackTrace(printWriter);
 165             System.out.println(writer);
 166             fail();
 167         }
 168     }
 169
 170     @Test
 171     public void testJsonSchemaTranslateVertex() {
 172         try {
 173             String testSchema = readFile("src/test/resources/json/jsonSchema.json");
 174             JsonSchemaProvider schemaProvider = new JsonSchemaProvider(config);
 175             schemaProvider.loadSchema(testSchema, schemaProvider.getLatestSchemaVersion());
 176
 177             VertexSchema vertSchema = schemaProvider.getVertexSchema("tosca.nodes.objectstorage",
 178                     schemaProvider.getLatestSchemaVersion());
 179             System.out.println(vertSchema.toString());
 180
 181             // Validate vertex schema
 182             assertEquals("tosca.nodes.ObjectStorage", vertSchema.getName());
 183             assertEquals("size,name", vertSchema.getAnnotationValue("searchable"));
 184             assertEquals("aai-uuid,name", vertSchema.getAnnotationValue("indexedProps"));
 185
 186             PropertySchema propSchema = vertSchema.getPropertySchema("Name");
 187             assertEquals("name", propSchema.getName());
 188             assertEquals("", propSchema.getDefaultValue());
 189             assertTrue(propSchema.isRequired());
 190             assertFalse(propSchema.isKey());
 191             assertFalse(propSchema.isReserved());
 192             assertEquals(0, propSchema.getDataType().getType().compareTo(Type.STRING));
 193             assertEquals("AAI", propSchema.getAnnotationValue("Source_of_truth_type"));
 194
 195             propSchema = vertSchema.getPropertySchema("Size");
 196             assertEquals("size", propSchema.getName());
 197             assertEquals("50", propSchema.getDefaultValue());
 198             assertEquals(0, propSchema.getDataType().getType().compareTo(Type.INT));
 199
 200             propSchema = vertSchema.getPropertySchema("source-of-truth");
 201             assertEquals("source-of-truth", propSchema.getName());
 202             assertFalse(propSchema.isRequired());
 203             assertTrue(propSchema.isReserved());
 204             assertEquals(0, propSchema.getDataType().getType().compareTo(Type.STRING));
 205         } catch (Exception ex) {
 206             StringWriter writer = new StringWriter();
 207             PrintWriter printWriter = new PrintWriter(writer);
 208             ex.printStackTrace(printWriter);
 209             System.out.println(writer);
 210             fail();
 211         }
 212     }
 213
 214     @Test
 215     public void testJsonSchemaTranslateEdge() {
 216         try {
 217             String testSchema = readFile("src/test/resources/json/jsonSchema.json");
 218             JsonSchemaProvider schemaProvider = new JsonSchemaProvider(config);
 219             schemaProvider.loadSchema(testSchema, schemaProvider.getLatestSchemaVersion());
 220
 221             EdgeSchema edgeSchema = schemaProvider.getEdgeSchema("tosca.relationships.hostedOn",
 222                     "tosca.nodes.Softwarecomponent", "tosca.nodes.compute", schemaProvider.getLatestSchemaVersion());
 223             System.out.println(edgeSchema.toString());
 224
 225             // Validate edge schema
 226             assertEquals("tosca.relationships.HostedOn", edgeSchema.getName());
 227             assertEquals("tosca.nodes.SoftwareComponent", edgeSchema.getSource());
 228             assertEquals("tosca.nodes.Compute", edgeSchema.getTarget());
 229             assertEquals(edgeSchema.getMultiplicity(), EdgeSchema.Multiplicity.MANY_2_MANY);
 230             assertEquals("NONE", edgeSchema.getAnnotationValue("contains-other-v"));
 231
 232         } catch (Exception ex) {
 233             StringWriter writer = new StringWriter();
 234             PrintWriter printWriter = new PrintWriter(writer);
 235             ex.printStackTrace(printWriter);
 236             System.out.println(writer);
 237             fail();
 238         }
 239     }
 240
 241     @Test
 242     public void testJsonSchemaTranslateAdjacentEdge() {
 243         try {
 244             String testSchema = readFile("src/test/resources/json/jsonSchema.json");
 245             JsonSchemaProvider schemaProvider = new JsonSchemaProvider(config);
 246             schemaProvider.loadSchema(testSchema, schemaProvider.getLatestSchemaVersion());
 247
 248             Set<EdgeSchema> edgeSchemaList = schemaProvider.getAdjacentEdgeSchema("tosca.nodes.Database",
 249                     schemaProvider.getLatestSchemaVersion());
 250
 251             // Validate edge schema
 252             assertEquals(3, edgeSchemaList.size());
 253
 254             for (EdgeSchema es : edgeSchemaList) {
 255                 System.out.println(es.toString());
 256                 switch (es.getName()) {
 257                     case "tosca.relationships.HostedOn":
 258                         assertEquals("tosca.nodes.Database", es.getSource());
 259                         assertEquals("tosca.nodes.DBMS", es.getTarget());
 260                         assertEquals(es.getMultiplicity(), EdgeSchema.Multiplicity.MANY_2_MANY);
 261                         break;
 262                     case "tosca.relationships.RoutesTo":
 263                     case "tosca.relationships.Uses":
 264                         assertEquals("tosca.nodes.LoadBalancer", es.getSource());
 265                         assertEquals("tosca.nodes.Database", es.getTarget());
 266                         assertEquals(es.getMultiplicity(), EdgeSchema.Multiplicity.MANY_2_MANY);
 267                         break;
 268                     default:
 269                         fail();
 270                         break;
 271                 }
 272             }
 273         } catch (Exception ex) {
 274             StringWriter writer = new StringWriter();
 275             PrintWriter printWriter = new PrintWriter(writer);
 276             ex.printStackTrace(printWriter);
 277             System.out.println(writer);
 278             fail();
 279         }
 280     }
 281
 282     @Test
 283     public void testJsonSchemaSourceTargetEdges() {
 284         try {
 285             String testSchema = readFile("src/test/resources/json/jsonSchema.json");
 286             JsonSchemaProvider schemaProvider = new JsonSchemaProvider(config);
 287             schemaProvider.loadSchema(testSchema, schemaProvider.getLatestSchemaVersion());
 288
 289             Set<EdgeSchema> edgeSchemaList = schemaProvider.getEdgeSchemaForSourceTarget("tosca.nodes.LoadBalancer",
 290                     "tosca.nodes.Database", schemaProvider.getLatestSchemaVersion());
 291
 292             // Validate edge schema
 293             assertEquals(2, edgeSchemaList.size());
 294
 295             for (EdgeSchema es : edgeSchemaList) {
 296                 System.out.println(es.toString());
 297                 if (es.getName().equals("tosca.relationships.Uses")) {
 298                     assertEquals("tosca.nodes.LoadBalancer", es.getSource());
 299                     assertEquals("tosca.nodes.Database", es.getTarget());
 300                     assertEquals(es.getMultiplicity(), EdgeSchema.Multiplicity.MANY_2_MANY);
 301                 } else if (es.getName().equals("tosca.relationships.RoutesTo")) {
 302                     assertEquals("tosca.nodes.LoadBalancer", es.getSource());
 303                     assertEquals("tosca.nodes.Database", es.getTarget());
 304                     assertEquals(es.getMultiplicity(), EdgeSchema.Multiplicity.MANY_2_MANY);
 305                 } else {
 306                     fail();
 307                 }
 308             }
 309         } catch (Exception ex) {
 310             StringWriter writer = new StringWriter();
 311             PrintWriter printWriter = new PrintWriter(writer);
 312             ex.printStackTrace(printWriter);
 313             System.out.println(writer);
 314             fail();
 315         }
 316     }
 317
 318     @Test
 319     public void testJsonSchemaWildcardEdges() {
 320         try {
 321             String testSchema = readFile("src/test/resources/json/jsonSchema.json");
 322             JsonSchemaProvider schemaProvider = new JsonSchemaProvider(config);
 323             schemaProvider.loadSchema(testSchema, schemaProvider.getLatestSchemaVersion());
 324
 325             EdgeSchema edgeSchema = schemaProvider.getEdgeSchema("amdocs.linkedTo", "service-instance",
 326                     "onap.nodes.sdwan.ManagementDomain", schemaProvider.getLatestSchemaVersion());
 327
 328             assertEquals("amdocs.linkedTo", edgeSchema.getName());
 329             assertEquals("service-instance", edgeSchema.getSource());
 330             assertEquals("onap.nodes.sdwan.ManagementDomain", edgeSchema.getTarget());
 331
 332             edgeSchema = schemaProvider.getEdgeSchema("amdocs.linkedTo", "onap.nodes.sdwan.ManagementDomain",
 333                     "service-instance", schemaProvider.getLatestSchemaVersion());
 334
 335             assertNull(edgeSchema);
 336
 337             edgeSchema = schemaProvider.getEdgeSchema("amdocs.unknownRelationship", "unknown",
 338                     "onap.nodes.sdwan.ManagementDomain", schemaProvider.getLatestSchemaVersion());
 339
 340             assertEquals("amdocs.unknownRelationship", edgeSchema.getName());
 341             assertEquals("unknown", edgeSchema.getSource());
 342             assertEquals("onap.nodes.sdwan.ManagementDomain", edgeSchema.getTarget());
 343
 344             edgeSchema = schemaProvider.getEdgeSchema("amdocs.unknownRelationship", "onap.nodes.sdwan.ManagementDomain",
 345                     "unknown", schemaProvider.getLatestSchemaVersion());
 346
 347             assertEquals("amdocs.unknownRelationship", edgeSchema.getName());
 348             assertEquals("onap.nodes.sdwan.ManagementDomain", edgeSchema.getSource());
 349             assertEquals("unknown", edgeSchema.getTarget());
 350
 351             Set<EdgeSchema> edgeSchemaList = schemaProvider.getEdgeSchemaForSourceTarget("service-instance",
 352                     "onap.nodes.sdwan.ManagementDomain", schemaProvider.getLatestSchemaVersion());
 353             assertEquals(1, edgeSchemaList.size());
 354
 355             edgeSchemaList = schemaProvider.getEdgeSchemaForSourceTarget("unknown", "unknown",
 356                     schemaProvider.getLatestSchemaVersion());
 357             assertEquals(1, edgeSchemaList.size());
 358
 359             edgeSchemaList = schemaProvider.getEdgeSchemaForSourceTarget("service-instance", "service-instance",
 360                     schemaProvider.getLatestSchemaVersion());
 361             assertEquals(1, edgeSchemaList.size());
 362
 363             edgeSchemaList =
 364                     schemaProvider.getAdjacentEdgeSchema("service-instance", schemaProvider.getLatestSchemaVersion());
 365             System.out.println("EDGE LIST: \n\n" + edgeSchemaList);
 366             assertEquals(8, edgeSchemaList.size());
 367         } catch (Exception ex) {
 368             StringWriter writer = new StringWriter();
 369             PrintWriter printWriter = new PrintWriter(writer);
 370             ex.printStackTrace(printWriter);
 371             System.out.println(writer);
 372             fail();
 373         }
 374     }
 375
 376     @Test
 377     public void testInvalidVertexOrEdge() {
 378         try {
 379             String testSchema = readFile("src/test/resources/json/jsonSchema.json");
 380             JsonSchemaProvider schemaProvider = new JsonSchemaProvider(config);
 381             schemaProvider.loadSchema(testSchema, schemaProvider.getLatestSchemaVersion());
 382
 383             VertexSchema vertSchema =
 384                     schemaProvider.getVertexSchema("bad-node", schemaProvider.getLatestSchemaVersion());
 385             assertNull(vertSchema);
 386
 387             EdgeSchema edgeSchema = schemaProvider.getEdgeSchema("org.onap.relationships.inventory.LocatedIn",
 388                     "cloud-region", "bad-node", schemaProvider.getLatestSchemaVersion());
 389             assertNull(edgeSchema);
 390
 391             Set<EdgeSchema> edgeSchemaList = schemaProvider.getAdjacentEdgeSchema("org.onap.nodes.bad-node",
 392                     schemaProvider.getLatestSchemaVersion());
 393             assertTrue(edgeSchemaList.isEmpty());
 394         } catch (Exception ex) {
 395             StringWriter writer = new StringWriter();
 396             PrintWriter printWriter = new PrintWriter(writer);
 397             ex.printStackTrace(printWriter);
 398             System.out.println(writer);
 399             fail();
 400         }
 401     }
 402
 403     @Test
 404     public void testJsonSchemaListAttribute() {
 405         try {
 406             String testSchema = readFile("src/test/resources/json/jsonSchema.json");
 407             JsonSchemaProvider schemaProvider = new JsonSchemaProvider(config);
 408             schemaProvider.loadSchema(testSchema, schemaProvider.getLatestSchemaVersion());
 409
 410             VertexSchema vertSchema = schemaProvider.getVertexSchema("onap.nodes.sdwan.ManagementDomain",
 411                     schemaProvider.getLatestSchemaVersion());
 412             System.out.println(vertSchema.toString());
 413
 414             // Validate schema
 415             PropertySchema propSchema = vertSchema.getPropertySchema("controllers");
 416             assertEquals(0, propSchema.getDataType().getType().compareTo(Type.LIST));
 417             ListDataType listType = (ListDataType) propSchema.getDataType();
 418             assertEquals(0, listType.getListType().getType().compareTo(Type.STRING));
 419         } catch (Exception ex) {
 420             StringWriter writer = new StringWriter();
 421             PrintWriter printWriter = new PrintWriter(writer);
 422             ex.printStackTrace(printWriter);
 423             System.out.println(writer);
 424             fail();
 425         }
 426     }
 427
 428     @Test
 429     public void testJsonSchemaMapAttribute() {
 430         try {
 431             String testSchema = readFile("src/test/resources/json/jsonSchema.json");
 432             JsonSchemaProvider schemaProvider = new JsonSchemaProvider(config);
 433             schemaProvider.loadSchema(testSchema, schemaProvider.getLatestSchemaVersion());
 434
 435             VertexSchema vertSchema = schemaProvider.getVertexSchema("onap.nodes.sdwan.ManagementDomain",
 436                     schemaProvider.getLatestSchemaVersion());
 437             System.out.println(vertSchema.toString());
 438
 439             // Validate schema
 440             PropertySchema propSchema = vertSchema.getPropertySchema("analyticClusters");
 441             assertEquals(0, propSchema.getDataType().getType().compareTo(Type.MAP));
 442             MapDataType mapType = (MapDataType) propSchema.getDataType();
 443             assertEquals(0, mapType.getMapType().getType().compareTo(Type.STRING));
 444         } catch (Exception ex) {
 445             StringWriter writer = new StringWriter();
 446             PrintWriter printWriter = new PrintWriter(writer);
 447             ex.printStackTrace(printWriter);
 448             System.out.println(writer);
 449             fail();
 450         }
 451     }
 452
 453     @Test
 454     public void testJsonSchemaComplexAttribute() {
 455         try {
 456             String testSchema = readFile("src/test/resources/json/jsonSchema.json");
 457             JsonSchemaProvider schemaProvider = new JsonSchemaProvider(config);
 458             schemaProvider.loadSchema(testSchema, schemaProvider.getLatestSchemaVersion());
 459
 460             VertexSchema vertSchema = schemaProvider.getVertexSchema("org.onap.resource.extContrailCP",
 461                     schemaProvider.getLatestSchemaVersion());
 462             System.out.println(vertSchema.toString());
 463
 464             System.out.println("\n\nSize: " + vertSchema.getPropertySchemaList().size());
 465             System.out.println(vertSchema.getPropertySchemaList());
 466             assertEquals(22, vertSchema.getPropertySchemaList().size());
 467
 468             // Validate property schema
 469             PropertySchema propSchema = vertSchema.getPropertySchema("exCP_naming");
 470             assertEquals(0, propSchema.getDataType().getType().compareTo(Type.COMPLEX));
 471             ComplexDataType complexType = (ComplexDataType) propSchema.getDataType();
 472             List<PropertySchema> complexProps = complexType.getSubProperties();
 473             assertEquals(4, complexProps.size());
 474
 475             PropertySchema subProp = null;
 476             for (PropertySchema p : complexProps) {
 477                 if (p.getName().equals("naming_policy")) {
 478                     subProp = p;
 479                 }
 480             }
 481
 482             assertNotNull(subProp);
 483             assertFalse(subProp.isRequired());
 484             assertEquals(0, subProp.getDataType().getType().compareTo(Type.STRING));
 485         } catch (Exception ex) {
 486             StringWriter writer = new StringWriter();
 487             PrintWriter printWriter = new PrintWriter(writer);
 488             ex.printStackTrace(printWriter);
 489             System.out.println(writer);
 490             fail();
 491         }
 492     }
 493
 494     @Test
 495     public void testParseSchemaServiceResponse() {
 496         try {
 497             String testSchema = readFile("src/test/resources/json/schemaServiceResponse.json");
 498             SchemaServiceResponse resp = SchemaServiceResponse.fromJson(testSchema);
 499
 500             System.out.println(resp.toJson());
 501             assertEquals("v1", resp.getVersion());
 502
 503             JsonSchema jsonSchema = resp.getData();
 504             System.out.println(jsonSchema.toJson());
 505
 506             assertEquals(1, jsonSchema.getDataTypes().size());
 507         } catch (Exception ex) {
 508             StringWriter writer = new StringWriter();
 509             PrintWriter printWriter = new PrintWriter(writer);
 510             ex.printStackTrace(printWriter);
 511             System.out.println(writer);
 512             fail();
 513         }
 514     }
 515
 516     @Test
 517     public void testSchemaValidateSuccess() {
 518         try {
 519             String testSchema = readFile("src/test/resources/json/schemaServiceResponse.json");
 520             SchemaServiceResponse schema = SchemaServiceResponse.fromJson(testSchema);
 521             schema.getData().validate();
 522         } catch (Exception ex) {
 523             StringWriter writer = new StringWriter();
 524             PrintWriter printWriter = new PrintWriter(writer);
 525             ex.printStackTrace(printWriter);
 526             System.out.println(writer);
 527             fail();
 528         }
 529     }
 530
 531     @Test(expected = SchemaProviderException.class)
 532     public void testSchemaValidateBadEdge() throws SchemaProviderException {
 533         SchemaServiceResponse schema;
 534
 535         try {
 536             String testSchema = readFile("src/test/resources/json/badEdgeSchema.json");
 537             schema = SchemaServiceResponse.fromJson(testSchema);
 538         } catch (Exception ex) {
 539             fail();
 540             return;
 541         }
 542
 543         schema.getData().validate();
 544     }
 545
 546     @Test(expected = SchemaProviderException.class)
 547     public void testSchemaValidateBadVertex() throws SchemaProviderException {
 548         SchemaServiceResponse schema;
 549
 550         try {
 551             String testSchema = readFile("src/test/resources/json/badVertexSchema.json");
 552             schema = SchemaServiceResponse.fromJson(testSchema);
 553         } catch (Exception ex) {
 554             fail();
 555             return;
 556         }
 557
 558         System.out.println("Validate");
 559         schema.getData().validate();
 560         System.out.println("Validate done");
 561     }
 562
 563     @Test(expected = SchemaProviderException.class)
 564     public void testSchemaValidateBadType() throws SchemaProviderException {
 565         SchemaServiceResponse schema;
 566
 567         try {
 568             String testSchema = readFile("src/test/resources/json/badTypeSchema.json");
 569             schema = SchemaServiceResponse.fromJson(testSchema);
 570         } catch (Exception ex) {
 571             fail();
 572             return;
 573         }
 574
 575         schema.getData().validate();
 576     }
 577
 578     @Test(expected = SchemaProviderException.class)
 579     public void testSchemaValidateBadProp() throws SchemaProviderException {
 580         SchemaServiceResponse schema;
 581
 582         try {
 583             String testSchema = readFile("src/test/resources/json/badPropSchema.json");
 584             schema = SchemaServiceResponse.fromJson(testSchema);
 585         } catch (Exception ex) {
 586             fail();
 587             return;
 588         }
 589
 590         schema.getData().validate();
 591     }
 592
 593     static String readFile(String path) throws IOException {
 594         byte[] encoded = Files.readAllBytes(Paths.get(path));
 595         return new String(encoded);
 596     }
 597 }