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 import org.junit.Before;
  42 import org.junit.Test;
  43 import org.onap.aai.schemaif.SchemaProviderException;
  44 import org.onap.aai.schemaif.definitions.EdgeSchema;
  45 import org.onap.aai.schemaif.definitions.PropertySchema;
  46 import org.onap.aai.schemaif.definitions.VertexSchema;
  47 import org.onap.aai.schemaif.definitions.types.ComplexDataType;
  48 import org.onap.aai.schemaif.definitions.types.DataType.Type;
  49 import org.onap.aai.schemaif.definitions.types.ListDataType;
  50 import org.onap.aai.schemaif.definitions.types.MapDataType;
  51 import org.onap.aai.schemaif.json.definitions.DataTypeDefinition;
  52 import org.onap.aai.schemaif.json.definitions.JsonEdgeSchema;
  53 import org.onap.aai.schemaif.json.definitions.JsonPropertySchema;
  54 import org.onap.aai.schemaif.json.definitions.JsonSchema;
  55 import org.onap.aai.schemaif.json.definitions.JsonVertexSchema;
  56
  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         }
 162         catch (Exception ex) {
 163             StringWriter writer = new StringWriter();
 164             PrintWriter printWriter = new PrintWriter(writer);
 165             ex.printStackTrace(printWriter);
 166             System.out.println(writer);
 167             fail();
 168         }
 169     }
 170
 171     @Test
 172     public void testJsonSchemaTranslateVertex() {
 173         try {
 174             String testSchema = readFile("src/test/resources/json/jsonSchema.json");
 175             JsonSchemaProvider schemaProvider = new JsonSchemaProvider(config);
 176             schemaProvider.loadSchema(testSchema, schemaProvider.getLatestSchemaVersion());
 177
 178             VertexSchema vertSchema =
 179                     schemaProvider.getVertexSchema("tosca.nodes.objectstorage",
 180                             schemaProvider.getLatestSchemaVersion());
 181             System.out.println(vertSchema.toString());
 182
 183             // Validate vertex schema
 184             assertEquals("tosca.nodes.ObjectStorage", vertSchema.getName());
 185             assertEquals("size,name", vertSchema.getAnnotationValue("searchable"));
 186             assertEquals("aai-uuid,name", vertSchema.getAnnotationValue("indexedProps"));
 187
 188             PropertySchema propSchema = vertSchema.getPropertySchema("Name");
 189             assertEquals("name", propSchema.getName());
 190             assertEquals("", propSchema.getDefaultValue());
 191             assertTrue(propSchema.isRequired());
 192             assertFalse(propSchema.isKey());
 193             assertFalse(propSchema.isReserved());
 194             assertEquals(0, propSchema.getDataType().getType().compareTo(Type.STRING));
 195             assertEquals("AAI", propSchema.getAnnotationValue("Source_of_truth_type"));
 196
 197             propSchema = vertSchema.getPropertySchema("Size");
 198             assertEquals("size", propSchema.getName());
 199             assertEquals("50", propSchema.getDefaultValue());
 200             assertEquals(0, propSchema.getDataType().getType().compareTo(Type.INT));
 201
 202             propSchema = vertSchema.getPropertySchema("source-of-truth");
 203             assertEquals("source-of-truth", propSchema.getName());
 204             assertFalse(propSchema.isRequired());
 205             assertTrue(propSchema.isReserved());
 206             assertEquals(0, propSchema.getDataType().getType().compareTo(Type.STRING));
 207         }
 208         catch (Exception ex) {
 209             StringWriter writer = new StringWriter();
 210             PrintWriter printWriter = new PrintWriter(writer);
 211             ex.printStackTrace(printWriter);
 212             System.out.println(writer);
 213             fail();
 214         }
 215     }
 216
 217     @Test
 218     public void testJsonSchemaTranslateEdge() {
 219         try {
 220             String testSchema = readFile("src/test/resources/json/jsonSchema.json");
 221             JsonSchemaProvider schemaProvider = new JsonSchemaProvider(config);
 222             schemaProvider.loadSchema(testSchema, schemaProvider.getLatestSchemaVersion());
 223
 224             EdgeSchema edgeSchema = schemaProvider.getEdgeSchema("tosca.relationships.hostedOn",
 225                     "tosca.nodes.Softwarecomponent", "tosca.nodes.compute",
 226                     schemaProvider.getLatestSchemaVersion());
 227             System.out.println(edgeSchema.toString());
 228
 229             // Validate edge schema
 230             assertEquals("tosca.relationships.HostedOn", edgeSchema.getName());
 231             assertEquals("tosca.nodes.SoftwareComponent", edgeSchema.getSource());
 232             assertEquals("tosca.nodes.Compute", edgeSchema.getTarget());
 233             assertEquals(edgeSchema.getMultiplicity(), EdgeSchema.Multiplicity.MANY_2_MANY);
 234             assertEquals("NONE", edgeSchema.getAnnotationValue("contains-other-v"));
 235
 236
 237         }
 238         catch (Exception ex) {
 239             StringWriter writer = new StringWriter();
 240             PrintWriter printWriter = new PrintWriter(writer);
 241             ex.printStackTrace(printWriter);
 242             System.out.println(writer);
 243             fail();
 244         }
 245     }
 246
 247     @Test
 248     public void testJsonSchemaTranslateAdjacentEdge() {
 249         try {
 250             String testSchema = readFile("src/test/resources/json/jsonSchema.json");
 251             JsonSchemaProvider schemaProvider = new JsonSchemaProvider(config);
 252             schemaProvider.loadSchema(testSchema, schemaProvider.getLatestSchemaVersion());
 253
 254             Set<EdgeSchema> edgeSchemaList =
 255                     schemaProvider.getAdjacentEdgeSchema("tosca.nodes.Database",
 256                             schemaProvider.getLatestSchemaVersion());
 257
 258             // Validate edge schema
 259             assertEquals(3, edgeSchemaList.size());
 260
 261             for (EdgeSchema es : edgeSchemaList) {
 262                 System.out.println(es.toString());
 263                 switch (es.getName()) {
 264                     case "tosca.relationships.HostedOn":
 265                         assertEquals("tosca.nodes.Database", es.getSource());
 266                         assertEquals("tosca.nodes.DBMS", es.getTarget());
 267                         assertEquals(es.getMultiplicity(), EdgeSchema.Multiplicity.MANY_2_MANY);
 268                         break;
 269                     case "tosca.relationships.RoutesTo":
 270                     case "tosca.relationships.Uses":
 271                         assertEquals("tosca.nodes.LoadBalancer", es.getSource());
 272                         assertEquals("tosca.nodes.Database", es.getTarget());
 273                         assertEquals(es.getMultiplicity(), EdgeSchema.Multiplicity.MANY_2_MANY);
 274                         break;
 275                     default:
 276                         fail();
 277                         break;
 278                 }
 279             }
 280         }
 281         catch (Exception ex) {
 282             StringWriter writer = new StringWriter();
 283             PrintWriter printWriter = new PrintWriter(writer);
 284             ex.printStackTrace(printWriter);
 285             System.out.println(writer);
 286             fail();
 287         }
 288     }
 289
 290     @Test
 291     public void testJsonSchemaSourceTargetEdges() {
 292         try {
 293             String testSchema = readFile("src/test/resources/json/jsonSchema.json");
 294             JsonSchemaProvider schemaProvider = new JsonSchemaProvider(config);
 295             schemaProvider.loadSchema(testSchema, schemaProvider.getLatestSchemaVersion());
 296
 297             Set<EdgeSchema> edgeSchemaList =
 298                     schemaProvider.getEdgeSchemaForSourceTarget("tosca.nodes.LoadBalancer",
 299                             "tosca.nodes.Database",
 300                             schemaProvider.getLatestSchemaVersion());
 301
 302             // Validate edge schema
 303             assertEquals(2, edgeSchemaList.size());
 304
 305             for (EdgeSchema es : edgeSchemaList) {
 306                 System.out.println(es.toString());
 307                 if (es.getName().equals("tosca.relationships.Uses")) {
 308                     assertEquals("tosca.nodes.LoadBalancer", es.getSource());
 309                     assertEquals("tosca.nodes.Database", es.getTarget());
 310                     assertEquals(es.getMultiplicity(), EdgeSchema.Multiplicity.MANY_2_MANY);
 311                 }
 312                 else if (es.getName().equals("tosca.relationships.RoutesTo")) {
 313                     assertEquals("tosca.nodes.LoadBalancer", es.getSource());
 314                     assertEquals("tosca.nodes.Database", es.getTarget());
 315                     assertEquals(es.getMultiplicity(), EdgeSchema.Multiplicity.MANY_2_MANY);
 316                 }
 317                 else {
 318                     fail();
 319                 }
 320             }
 321         }
 322         catch (Exception ex) {
 323             StringWriter writer = new StringWriter();
 324             PrintWriter printWriter = new PrintWriter(writer);
 325             ex.printStackTrace(printWriter);
 326             System.out.println(writer);
 327             fail();
 328         }
 329     }
 330
 331     @Test
 332     public void testJsonSchemaWildcardEdges() {
 333         try {
 334             String testSchema = readFile("src/test/resources/json/jsonSchema.json");
 335             JsonSchemaProvider schemaProvider = new JsonSchemaProvider(config);
 336             schemaProvider.loadSchema(testSchema, schemaProvider.getLatestSchemaVersion());
 337
 338             EdgeSchema edgeSchema =
 339                     schemaProvider.getEdgeSchema("amdocs.linkedTo", "service-instance",
 340                             "onap.nodes.sdwan.ManagementDomain", schemaProvider.getLatestSchemaVersion());
 341
 342             assertEquals("amdocs.linkedTo", edgeSchema.getName());
 343             assertEquals("service-instance", edgeSchema.getSource());
 344             assertEquals("onap.nodes.sdwan.ManagementDomain", edgeSchema.getTarget());
 345
 346             edgeSchema = schemaProvider.getEdgeSchema("amdocs.linkedTo", "onap.nodes.sdwan.ManagementDomain",
 347                     "service-instance", schemaProvider.getLatestSchemaVersion());
 348
 349             assertNull(edgeSchema);
 350
 351
 352             edgeSchema =
 353                     schemaProvider.getEdgeSchema("amdocs.unknownRelationship", "unknown",
 354                             "onap.nodes.sdwan.ManagementDomain", schemaProvider.getLatestSchemaVersion());
 355
 356             assertEquals("amdocs.unknownRelationship", edgeSchema.getName());
 357             assertEquals("unknown", edgeSchema.getSource());
 358             assertEquals("onap.nodes.sdwan.ManagementDomain", edgeSchema.getTarget());
 359
 360             edgeSchema =
 361                     schemaProvider.getEdgeSchema("amdocs.unknownRelationship", "onap.nodes.sdwan.ManagementDomain",
 362                             "unknown", schemaProvider.getLatestSchemaVersion());
 363
 364             assertEquals("amdocs.unknownRelationship", edgeSchema.getName());
 365             assertEquals("onap.nodes.sdwan.ManagementDomain", edgeSchema.getSource());
 366             assertEquals("unknown", edgeSchema.getTarget());
 367
 368             Set<EdgeSchema> edgeSchemaList =
 369                     schemaProvider.getEdgeSchemaForSourceTarget("service-instance",
 370                             "onap.nodes.sdwan.ManagementDomain",
 371                             schemaProvider.getLatestSchemaVersion());
 372             assertEquals(1, edgeSchemaList.size());
 373
 374             edgeSchemaList = schemaProvider.getEdgeSchemaForSourceTarget("unknown", "unknown",
 375                     schemaProvider.getLatestSchemaVersion());
 376             assertEquals(1, edgeSchemaList.size());
 377
 378             edgeSchemaList = schemaProvider.getEdgeSchemaForSourceTarget("service-instance", "service-instance",
 379                     schemaProvider.getLatestSchemaVersion());
 380             assertEquals(1, edgeSchemaList.size());
 381
 382
 383             edgeSchemaList = schemaProvider.getAdjacentEdgeSchema("service-instance", schemaProvider.getLatestSchemaVersion());
 384             System.out.println("EDGE LIST: \n\n" + edgeSchemaList);
 385             assertEquals(8, edgeSchemaList.size());
 386         }
 387         catch (Exception ex) {
 388             StringWriter writer = new StringWriter();
 389             PrintWriter printWriter = new PrintWriter(writer);
 390             ex.printStackTrace(printWriter);
 391             System.out.println(writer);
 392             fail();
 393         }
 394     }
 395
 396     @Test
 397     public void testInvalidVertexOrEdge() {
 398         try {
 399             String testSchema = readFile("src/test/resources/json/jsonSchema.json");
 400             JsonSchemaProvider schemaProvider = new JsonSchemaProvider(config);
 401             schemaProvider.loadSchema(testSchema, schemaProvider.getLatestSchemaVersion());
 402
 403             VertexSchema vertSchema =
 404                     schemaProvider.getVertexSchema("bad-node", schemaProvider.getLatestSchemaVersion());
 405             assertNull(vertSchema);
 406
 407             EdgeSchema edgeSchema = schemaProvider.getEdgeSchema("org.onap.relationships.inventory.LocatedIn",
 408                     "cloud-region", "bad-node", schemaProvider.getLatestSchemaVersion());
 409             assertNull(edgeSchema);
 410
 411             Set<EdgeSchema> edgeSchemaList =
 412                     schemaProvider.getAdjacentEdgeSchema("org.onap.nodes.bad-node",
 413                             schemaProvider.getLatestSchemaVersion());
 414             assertTrue(edgeSchemaList.isEmpty());
 415         }
 416         catch (Exception ex) {
 417             StringWriter writer = new StringWriter();
 418             PrintWriter printWriter = new PrintWriter(writer);
 419             ex.printStackTrace(printWriter);
 420             System.out.println(writer);
 421             fail();
 422         }
 423     }
 424
 425     @Test
 426     public void testJsonSchemaListAttribute() {
 427         try {
 428             String testSchema = readFile("src/test/resources/json/jsonSchema.json");
 429             JsonSchemaProvider schemaProvider = new JsonSchemaProvider(config);
 430             schemaProvider.loadSchema(testSchema, schemaProvider.getLatestSchemaVersion());
 431
 432             VertexSchema vertSchema =
 433                     schemaProvider.getVertexSchema("onap.nodes.sdwan.ManagementDomain",
 434                             schemaProvider.getLatestSchemaVersion());
 435             System.out.println(vertSchema.toString());
 436
 437             // Validate schema
 438             PropertySchema propSchema = vertSchema.getPropertySchema("controllers");
 439             assertEquals(0, propSchema.getDataType().getType().compareTo(Type.LIST));
 440             ListDataType listType = (ListDataType)propSchema.getDataType();
 441             assertEquals(0, listType.getListType().getType().compareTo(Type.STRING));
 442         }
 443         catch (Exception ex) {
 444             StringWriter writer = new StringWriter();
 445             PrintWriter printWriter = new PrintWriter(writer);
 446             ex.printStackTrace(printWriter);
 447             System.out.println(writer);
 448             fail();
 449         }
 450     }
 451
 452     @Test
 453     public void testJsonSchemaMapAttribute() {
 454         try {
 455             String testSchema = readFile("src/test/resources/json/jsonSchema.json");
 456             JsonSchemaProvider schemaProvider = new JsonSchemaProvider(config);
 457             schemaProvider.loadSchema(testSchema, schemaProvider.getLatestSchemaVersion());
 458
 459             VertexSchema vertSchema =
 460                     schemaProvider.getVertexSchema("onap.nodes.sdwan.ManagementDomain",
 461                             schemaProvider.getLatestSchemaVersion());
 462             System.out.println(vertSchema.toString());
 463
 464             // Validate schema
 465             PropertySchema propSchema = vertSchema.getPropertySchema("analyticClusters");
 466             assertEquals(0, propSchema.getDataType().getType().compareTo(Type.MAP));
 467             MapDataType mapType = (MapDataType)propSchema.getDataType();
 468             assertEquals(0, mapType.getMapType().getType().compareTo(Type.STRING));
 469         }
 470         catch (Exception ex) {
 471             StringWriter writer = new StringWriter();
 472             PrintWriter printWriter = new PrintWriter(writer);
 473             ex.printStackTrace(printWriter);
 474             System.out.println(writer);
 475             fail();
 476         }
 477     }
 478
 479     @Test
 480     public void testJsonSchemaComplexAttribute() {
 481         try {
 482             String testSchema = readFile("src/test/resources/json/jsonSchema.json");
 483             JsonSchemaProvider schemaProvider = new JsonSchemaProvider(config);
 484             schemaProvider.loadSchema(testSchema, schemaProvider.getLatestSchemaVersion());
 485
 486             VertexSchema vertSchema =
 487                     schemaProvider.getVertexSchema("org.onap.resource.extContrailCP",
 488                             schemaProvider.getLatestSchemaVersion());
 489             System.out.println(vertSchema.toString());
 490
 491             System.out.println("\n\nSize: " + vertSchema.getPropertySchemaList().size());
 492             System.out.println(vertSchema.getPropertySchemaList());
 493             assertEquals(22, vertSchema.getPropertySchemaList().size());
 494
 495             // Validate property schema
 496             PropertySchema propSchema = vertSchema.getPropertySchema("exCP_naming");
 497             assertEquals(0, propSchema.getDataType().getType().compareTo(Type.COMPLEX));
 498             ComplexDataType complexType = (ComplexDataType)propSchema.getDataType();
 499             List<PropertySchema> complexProps = complexType.getSubProperties();
 500             assertEquals(4, complexProps.size());
 501
 502             PropertySchema subProp = null;
 503             for (PropertySchema p : complexProps) {
 504                 if (p.getName().equals("naming_policy")) {
 505                     subProp = p;
 506                 }
 507             }
 508
 509             assertNotNull(subProp);
 510             assertFalse(subProp.isRequired());
 511             assertEquals(0, subProp.getDataType().getType().compareTo(Type.STRING));
 512         }
 513         catch (Exception ex) {
 514             StringWriter writer = new StringWriter();
 515             PrintWriter printWriter = new PrintWriter(writer);
 516             ex.printStackTrace(printWriter);
 517             System.out.println(writer);
 518             fail();
 519         }
 520     }
 521
 522     @Test
 523     public void testParseSchemaServiceResponse() {
 524         try {
 525             String testSchema = readFile("src/test/resources/json/schemaServiceResponse.json");
 526             SchemaServiceResponse resp = SchemaServiceResponse.fromJson(testSchema);
 527
 528             System.out.println(resp.toJson());
 529             assertEquals("v1", resp.getVersion());
 530
 531             JsonSchema jsonSchema = resp.getData();
 532             System.out.println(jsonSchema.toJson());
 533
 534             assertEquals(1, jsonSchema.getDataTypes().size());
 535         }
 536         catch (Exception ex) {
 537             StringWriter writer = new StringWriter();
 538             PrintWriter printWriter = new PrintWriter(writer);
 539             ex.printStackTrace(printWriter);
 540             System.out.println(writer);
 541             fail();
 542         }
 543     }
 544
 545     @Test
 546     public void testSchemaValidateSuccess() {
 547         try {
 548             String testSchema = readFile("src/test/resources/json/schemaServiceResponse.json");
 549             SchemaServiceResponse schema = SchemaServiceResponse.fromJson(testSchema);
 550             schema.getData().validate();
 551         }
 552         catch (Exception ex) {
 553             StringWriter writer = new StringWriter();
 554             PrintWriter printWriter = new PrintWriter(writer);
 555             ex.printStackTrace(printWriter);
 556             System.out.println(writer);
 557             fail();
 558         }
 559     }
 560
 561     @Test(expected = SchemaProviderException.class)
 562     public void testSchemaValidateBadEdge() throws SchemaProviderException {
 563         SchemaServiceResponse schema;
 564
 565         try {
 566             String testSchema = readFile("src/test/resources/json/badEdgeSchema.json");
 567             schema = SchemaServiceResponse.fromJson(testSchema);
 568         }
 569         catch (Exception ex) {
 570             fail();
 571             return;
 572         }
 573
 574         schema.getData().validate();
 575     }
 576
 577     @Test(expected = SchemaProviderException.class)
 578     public void testSchemaValidateBadVertex() throws SchemaProviderException {
 579         SchemaServiceResponse schema;
 580
 581         try {
 582             String testSchema = readFile("src/test/resources/json/badVertexSchema.json");
 583             schema = SchemaServiceResponse.fromJson(testSchema);
 584         }
 585         catch (Exception ex) {
 586             fail();
 587             return;
 588         }
 589
 590         System.out.println("Validate");
 591         schema.getData().validate();
 592         System.out.println("Validate done");
 593     }
 594
 595     @Test(expected = SchemaProviderException.class)
 596     public void testSchemaValidateBadType() throws SchemaProviderException {
 597         SchemaServiceResponse schema;
 598
 599         try {
 600             String testSchema = readFile("src/test/resources/json/badTypeSchema.json");
 601             schema = SchemaServiceResponse.fromJson(testSchema);
 602         }
 603         catch (Exception ex) {
 604             fail();
 605             return;
 606         }
 607
 608         schema.getData().validate();
 609     }
 610
 611     @Test(expected = SchemaProviderException.class)
 612     public void testSchemaValidateBadProp() throws SchemaProviderException {
 613         SchemaServiceResponse schema;
 614
 615         try {
 616             String testSchema = readFile("src/test/resources/json/badPropSchema.json");
 617             schema = SchemaServiceResponse.fromJson(testSchema);
 618         }
 619         catch (Exception ex) {
 620             fail();
 621             return;
 622         }
 623
 624         schema.getData().validate();
 625     }
 626
 627     static String readFile(String path) throws IOException {
 628         byte[] encoded = Files.readAllBytes(Paths.get(path));
 629         return new String(encoded);
 630     }
 631 }