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