2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
6 * ================================================================================
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 * ============LICENSE_END=========================================================
21 package org.onap.aai.serialization.db;
23 import static org.junit.Assert.assertEquals;
24 import static org.junit.Assert.assertFalse;
25 import static org.junit.Assert.assertTrue;
26 import static org.mockito.Mockito.spy;
27 import static org.mockito.Mockito.when;
29 import java.io.UnsupportedEncodingException;
30 import java.lang.reflect.Field;
32 import java.net.URISyntaxException;
33 import java.util.ArrayList;
34 import java.util.Arrays;
35 import java.util.Collections;
36 import java.util.List;
38 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
39 import org.apache.tinkerpop.gremlin.structure.Edge;
40 import org.apache.tinkerpop.gremlin.structure.Graph;
41 import org.apache.tinkerpop.gremlin.structure.Vertex;
42 import org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerGraph;
43 import org.junit.After;
44 import org.junit.Before;
45 import org.junit.Rule;
46 import org.junit.Test;
47 import org.junit.rules.ExpectedException;
48 import org.onap.aai.AAISetup;
49 import org.onap.aai.db.props.AAIProperties;
50 import org.onap.aai.dbmap.DBConnectionType;
51 import org.onap.aai.exceptions.AAIException;
52 import org.onap.aai.introspection.Introspector;
53 import org.onap.aai.introspection.Loader;
54 import org.onap.aai.introspection.LoaderFactory;
55 import org.onap.aai.introspection.ModelType;
56 import org.onap.aai.introspection.Version;
57 import org.onap.aai.parsers.query.QueryParser;
58 import org.onap.aai.serialization.engines.QueryStyle;
59 import org.onap.aai.serialization.engines.TitanDBEngine;
60 import org.onap.aai.serialization.engines.TransactionalGraphEngine;
62 import com.thinkaurelius.titan.core.TitanFactory;
64 public class DbSerializerTest extends AAISetup {
66 //to use, set thrown.expect to whatever your test needs
67 //this line establishes default of expecting no exception to be thrown
69 public ExpectedException thrown = ExpectedException.none();
71 protected Graph graph;
72 protected final EdgeRules rules = EdgeRules.getInstance();
74 private final Version version = Version.getLatest();
75 private final ModelType introspectorFactoryType = ModelType.MOXY;
76 private final QueryStyle queryStyle = QueryStyle.TRAVERSAL;
77 private final DBConnectionType type = DBConnectionType.REALTIME;
78 private Loader loader;
79 private TransactionalGraphEngine dbEngine;
80 private TransactionalGraphEngine engine; //for tests that aren't mocking the engine
81 private DBSerializer dbser;
82 TransactionalGraphEngine spy;
83 TransactionalGraphEngine.Admin adminSpy;
86 public void setup() throws Exception {
87 graph = TitanFactory.build().set("storage.backend", "inmemory").open();
88 loader = LoaderFactory.createLoaderForVersion(introspectorFactoryType, version);
89 dbEngine = new TitanDBEngine(queryStyle, type, loader);
91 adminSpy = spy(dbEngine.asAdmin());
95 engine = new TitanDBEngine(queryStyle, type, loader);
96 dbser = new DBSerializer(version, engine, introspectorFactoryType, "AAI-TEST");
99 public void createGraph() throws AAIException {
101 * This setus up the test graph, For future junits , add more vertices
105 Vertex l3interipv4addresslist_1 = graph.traversal().addV("aai-node-type", "l3-interface-ipv4-address-list",
106 "l3-interface-ipv4-address", "l3-interface-ipv4-address-1").next();
107 Vertex subnet_2 = graph.traversal().addV("aai-node-type", "subnet", "subnet-id", "subnet-id-2").next();
108 Vertex l3interipv6addresslist_3 = graph.traversal().addV("aai-node-type", "l3-interface-ipv6-address-list",
109 "l3-interface-ipv6-address", "l3-interface-ipv6-address-3").next();
110 Vertex subnet_4 = graph.traversal().addV("aai-node-type", "subnet", "subnet-id", "subnet-id-4").next();
111 Vertex subnet_5 = graph.traversal().addV("aai-node-type", "subnet", "subnet-id", "subnet-id-5").next();
112 Vertex l3network_6 = graph.traversal()
113 .addV("aai-node-type", "l3-network", "network-id", "network-id-6", "network-name", "network-name-6")
116 GraphTraversalSource g = graph.traversal();
117 rules.addEdge(g, l3interipv4addresslist_1, subnet_2);
118 rules.addEdge(g, l3interipv6addresslist_3, subnet_4);
119 rules.addTreeEdge(g, subnet_5, l3network_6);
124 public void tearDown() throws Exception {
129 public void subnetDelwithInEdgesIpv4Test() throws AAIException {
130 String expected_message = "Object is being reference by additional objects preventing it from being deleted. Please clean up references from the following types [l3-interface-ipv4-address-list]";
133 * This subnet has in-edges with l3-ipv4 and NOT ok to delete
135 Vertex subnet = graph.traversal().V().has("aai-node-type", "subnet").has("subnet-id", "subnet-id-2").next();
137 String exceptionMessage = testDelete(subnet);
138 assertEquals(expected_message, exceptionMessage);
143 public void subnetDelwithInEdgesIpv6Test() throws AAIException {
144 String expected_message = "Object is being reference by additional objects preventing it from being deleted. Please clean up references from the following types [l3-interface-ipv6-address-list]";
147 * This subnet has in-edges with l3-ipv6 and NOT ok to delete
149 Vertex subnet = graph.traversal().V().has("aai-node-type", "subnet").has("subnet-id", "subnet-id-4").next();
150 String exceptionMessage = testDelete(subnet);
151 assertEquals(expected_message, exceptionMessage);
156 public void subnetDelwithInEdgesL3network() throws AAIException {
157 String expected_message = "";
160 * This subnet has in-edges with l3-network and ok to delete
162 Vertex subnet = graph.traversal().V().has("aai-node-type", "subnet").has("subnet-id", "subnet-id-5").next();
164 String exceptionMessage = testDelete(subnet);
165 assertEquals(expected_message, exceptionMessage);
169 public String testDelete(Vertex v) throws AAIException {
171 // Graph g_tx = graph.newTransaction();
172 GraphTraversalSource traversal = graph.traversal();
173 when(spy.asAdmin()).thenReturn(adminSpy);
174 when(adminSpy.getTraversalSource()).thenReturn(traversal);
175 when(adminSpy.getReadOnlyTraversalSource()).thenReturn(traversal);
177 String exceptionMessage = "";
178 DBSerializer serializer = new DBSerializer(version, spy, introspectorFactoryType, "AAI_TEST");
180 serializer.delete(v, "resourceVersion", false);
181 } catch (AAIException exception) {
182 exceptionMessage = exception.getMessage();
185 return exceptionMessage;
190 public void createNewVertexTest() throws AAIException {
191 engine.startTransaction();
193 Introspector testObj = loader.introspectorFromName("generic-vnf");
195 Vertex testVertex = dbser.createNewVertex(testObj);
196 Vertex fromGraph = engine.tx().traversal().V().has("aai-node-type","generic-vnf").toList().get(0);
197 assertEquals(testVertex.id(), fromGraph.id());
198 assertEquals("AAI-TEST", fromGraph.property(AAIProperties.SOURCE_OF_TRUTH.toString()).value());
203 public void touchStandardVertexPropertiesTest() throws AAIException, InterruptedException {
204 engine.startTransaction();
205 DBSerializer dbser2 = new DBSerializer(Version.getLatest(), engine, introspectorFactoryType, "AAI-TEST-2");
207 Graph graph = TinkerGraph.open();
208 Vertex vert = graph.addVertex("aai-node-type", "generic-vnf");
210 dbser.touchStandardVertexProperties(vert, true);
211 String resverStart = (String)vert.property(AAIProperties.RESOURCE_VERSION.toString()).value();
212 String lastModTimeStart = (String)vert.property(AAIProperties.LAST_MOD_TS.toString()).value();
214 Thread.sleep(10); //bc the resource version is set based on current time in milliseconds,
215 //if this test runs through too fast the value may not change
216 //causing the test to fail. sleeping ensures a different value
218 dbser2.touchStandardVertexProperties(vert, false);
219 assertFalse(resverStart.equals((String)vert.property(AAIProperties.RESOURCE_VERSION.toString()).value()));
220 assertFalse(lastModTimeStart.equals((String)vert.property(AAIProperties.LAST_MOD_TS.toString()).value()));
221 assertEquals("AAI-TEST-2", (String)vert.property(AAIProperties.LAST_MOD_SOURCE_OF_TRUTH.toString()).value());
226 public void verifyResourceVersion_SunnyDayTest() throws AAIException {
227 engine.startTransaction();
229 assertTrue(dbser.verifyResourceVersion("delete", "vnfc", "abc", "abc", "vnfcs/vnfc/vnfcId"));
234 public void verifyResourceVersion_CreateWithRVTest() throws AAIException {
235 engine.startTransaction();
237 thrown.expect(AAIException.class);
238 thrown.expectMessage("resource-version passed for create of generic-vnfs/generic-vnf/myid");
240 dbser.verifyResourceVersion("create", "generic-vnf", null, "old-res-ver", "generic-vnfs/generic-vnf/myid");
247 public void verifyResourceVersion_MissingRVTest() throws AAIException {
248 engine.startTransaction();
250 thrown.expect(AAIException.class);
251 thrown.expectMessage("resource-version not passed for update of generic-vnfs/generic-vnf/myid");
253 dbser.verifyResourceVersion("update", "generic-vnf", "current-res-ver", null, "generic-vnfs/generic-vnf/myid");
260 public void verifyResourceVersion_MismatchRVTest() throws AAIException {
261 engine.startTransaction();
263 thrown.expect(AAIException.class);
264 thrown.expectMessage("resource-version MISMATCH for update of generic-vnfs/generic-vnf/myid");
266 dbser.verifyResourceVersion("update", "generic-vnf", "current-res-ver", "old-res-ver", "generic-vnfs/generic-vnf/myid");
273 public void trimClassNameTest() throws AAIException {
274 assertEquals("GenericVnf", dbser.trimClassName("GenericVnf"));
275 assertEquals("GenericVnf", dbser.trimClassName("org.onap.aai.GenericVnf"));
279 public void getURIForVertexTest() throws AAIException, URISyntaxException, UnsupportedEncodingException {
280 engine.startTransaction();
282 Vertex cr = engine.tx().addVertex("aai-node-type", "cloud-region", "cloud-owner", "me", "cloud-region-id", "123");
283 Vertex ten = engine.tx().addVertex("aai-node-type", "tenant", "tenant-id", "453");
284 EdgeRules rules = EdgeRules.getInstance();
285 rules.addTreeEdge(engine.tx().traversal(), cr, ten);
287 URI compare = new URI("/cloud-infrastructure/cloud-regions/cloud-region/me/123/tenants/tenant/453");
288 assertEquals(compare, dbser.getURIForVertex(ten));
290 cr.property("aai-node-type").remove();
291 URI compareFailure = new URI("/unknown-uri");
292 assertEquals(compareFailure, dbser.getURIForVertex(ten));
297 public void getVertexPropertiesTest() throws AAIException, UnsupportedEncodingException {
298 engine.startTransaction();
300 Vertex cr = engine.tx().addVertex("aai-node-type", "cloud-region", "cloud-owner", "me", "cloud-region-id", "123");
302 Introspector crIntro = dbser.getVertexProperties(cr);
303 assertEquals("cloud-region", crIntro.getDbName());
304 assertEquals("me", crIntro.getValue("cloud-owner"));
305 assertEquals("123", crIntro.getValue("cloud-region-id"));
310 public void setCachedURIsTest() throws AAIException, UnsupportedEncodingException, URISyntaxException {
311 engine.startTransaction();
313 Vertex cr = engine.tx().addVertex("aai-node-type", "cloud-region", "cloud-owner", "me", "cloud-region-id", "123");
314 Vertex ten = engine.tx().addVertex("aai-node-type", "tenant", "tenant-id", "453");
315 Vertex vs = engine.tx().addVertex("aai-node-type", "vserver", "vserver-id", "vs1",
316 AAIProperties.AAI_URI.toString(),
317 "/cloud-infrastructure/cloud-regions/cloud-region/me/123/tenants/tenant/453/vservers/vserver/vs1");
318 EdgeRules rules = EdgeRules.getInstance();
319 rules.addTreeEdge(engine.tx().traversal(), cr, ten);
320 rules.addTreeEdge(engine.tx().traversal(), ten, vs);
322 List<Vertex> vertices = new ArrayList<Vertex>(Arrays.asList(cr, ten, vs));
323 Introspector crIn = dbser.getVertexProperties(cr);
324 Introspector tenIn = dbser.getVertexProperties(ten);
325 Introspector vsIn = dbser.getVertexProperties(vs);
326 List<Introspector> intros = new ArrayList<Introspector>(Arrays.asList(crIn, tenIn, vsIn));
328 dbser.setCachedURIs(vertices, intros);
330 assertEquals("/cloud-infrastructure/cloud-regions/cloud-region/me/123",
331 (String)cr.property(AAIProperties.AAI_URI.toString()).value());
332 assertEquals("/cloud-infrastructure/cloud-regions/cloud-region/me/123/tenants/tenant/453",
333 (String)ten.property(AAIProperties.AAI_URI.toString()).value());
334 assertEquals("/cloud-infrastructure/cloud-regions/cloud-region/me/123/tenants/tenant/453/vservers/vserver/vs1",
335 (String)vs.property(AAIProperties.AAI_URI.toString()).value());
340 public void getEdgeBetweenTest() throws AAIException {
341 engine.startTransaction();
343 Vertex cr = engine.tx().addVertex("aai-node-type", "cloud-region", "cloud-owner", "me", "cloud-region-id", "123");
344 Vertex ten = engine.tx().addVertex("aai-node-type", "tenant", "tenant-id", "453");
345 EdgeRules rules = EdgeRules.getInstance();
346 rules.addTreeEdge(engine.tx().traversal(), cr, ten);
348 Edge e = dbser.getEdgeBetween(EdgeType.TREE, ten, cr, null);
349 assertEquals("has", e.label());
354 public void deleteEdgeTest() throws AAIException, UnsupportedEncodingException {
355 engine.startTransaction();
357 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
358 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
359 EdgeRules rules = EdgeRules.getInstance();
360 rules.addEdge(engine.tx().traversal(), gvnf, vnfc);
362 Introspector relData = loader.introspectorFromName("relationship-data");
363 relData.setValue("relationship-key", "vnfc.vnfc-name");
364 relData.setValue("relationship-value", "a-name");
365 Introspector relationship = loader.introspectorFromName("relationship");
366 relationship.setValue("related-to", "vnfc");
367 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
368 relationship.setValue("relationship-data",relData);
370 assertTrue(dbser.deleteEdge(relationship, gvnf));
372 assertFalse(engine.tx().traversal().V(gvnf).both("uses").hasNext());
373 assertFalse(engine.tx().traversal().V(vnfc).both("uses").hasNext());
378 public void createEdgeTest() throws AAIException, UnsupportedEncodingException {
379 engine.startTransaction();
381 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
382 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
385 Introspector relData = loader.introspectorFromName("relationship-data");
386 relData.setValue("relationship-key", "vnfc.vnfc-name");
387 relData.setValue("relationship-value", "a-name");
388 Introspector relationship = loader.introspectorFromName("relationship");
389 relationship.setValue("related-to", "vnfc");
390 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
391 relationship.setValue("relationship-data",relData);
393 assertTrue(dbser.createEdge(relationship, gvnf));
394 assertTrue(engine.tx().traversal().V(gvnf).both("uses").hasNext());
395 assertTrue(engine.tx().traversal().V(vnfc).both("uses").hasNext());
400 public void createCousinEdgeThatShouldBeTreeTest() throws AAIException, UnsupportedEncodingException, URISyntaxException {
401 engine.startTransaction();
403 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
404 Vertex vf = engine.tx().addVertex("aai-node-type","vf-module","vf-module-id","vf-id");
406 EdgeRules.getInstance().addTreeEdge(engine.tx().traversal(), gvnf, vf);
408 Introspector relationship = loader.introspectorFromName("relationship");
409 relationship.setValue("related-to", "vf-module");
410 relationship.setValue("related-link", dbser.getURIForVertex(vf).toString());
411 //relationship.setValue("relationship-label", "");
412 Introspector relationshipList = loader.introspectorFromName("relationship-list");
413 relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
415 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
416 Vertex gvnf2 = dbser.createNewVertex(gvnfObj);
417 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
418 gvnfObj.setValue("vnf-id", "myvnf-1");
420 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf-1"));
423 dbser.serializeToDb(gvnfObj, gvnf2, uriQuery, null, "test");
424 } catch (AAIException e) {
425 assertEquals("AAI_6145", e.getCode());
433 public void createEdgeNodeDoesNotExistExceptionTest() throws AAIException, UnsupportedEncodingException {
434 engine.startTransaction();
436 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
438 //rainy day case, edge to non-existent object
439 Introspector relData = loader.introspectorFromName("relationship-data");
440 relData.setValue("relationship-key", "vnfc.vnfc-name");
441 relData.setValue("relationship-value", "b-name");
442 Introspector relationship = loader.introspectorFromName("relationship");
443 relationship.setValue("related-to", "vnfc");
444 relationship.setValue("related-link", "/network/vnfcs/vnfc/b-name");
445 relationship.setValue("relationship-data",relData);
447 thrown.expect(AAIException.class);
448 thrown.expectMessage("Node of type vnfc. Could not find object at: /network/vnfcs/vnfc/b-name");
450 dbser.createEdge(relationship, gvnf);
457 public void serializeSingleVertexTopLevelTest() throws AAIException, UnsupportedEncodingException {
458 engine.startTransaction();
460 Introspector gvnf = loader.introspectorFromName("generic-vnf");
461 Vertex gvnfVert = dbser.createNewVertex(gvnf);
463 gvnf.setValue("vnf-id", "myvnf");
464 dbser.serializeSingleVertex(gvnfVert, gvnf, "test");
465 assertTrue(engine.tx().traversal().V().has("aai-node-type","generic-vnf").has("vnf-id","myvnf").hasNext());
470 public void serializeSingleVertexChildTest() throws AAIException, UnsupportedEncodingException {
471 engine.startTransaction();
473 Vertex cr = engine.tx().addVertex("aai-node-type", "cloud-region", "cloud-owner", "me", "cloud-region-id", "123");
474 Introspector tenIn = loader.introspectorFromName("tenant");
475 Vertex ten = dbser.createNewVertex(tenIn);
476 EdgeRules rules = EdgeRules.getInstance();
477 rules.addTreeEdge(engine.tx().traversal(), cr, ten);
479 tenIn.setValue("tenant-id", "453");
480 tenIn.setValue("tenant-name", "mytenant");
482 dbser.serializeSingleVertex(ten, tenIn, "test");
484 assertTrue(engine.tx().traversal().V().has("aai-node-type","tenant").has("tenant-id","453").has("tenant-name","mytenant").hasNext());
490 public void getVertexPropertiesRelationshipHasLabelTest() throws AAIException, UnsupportedEncodingException {
491 engine.startTransaction();
493 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","vnf-123");
494 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","vnfc-123");
495 EdgeRules rules = EdgeRules.getInstance();
496 rules.addEdge(engine.tx().traversal(), gvnf, vnfc);
498 Introspector obj = loader.introspectorFromName("generic-vnf");
499 obj = this.dbser.dbToObject(Arrays.asList(gvnf), obj, AAIProperties.MAXIMUM_DEPTH, false, "false");
501 assertEquals("edge label between generic-vnf and vnfs is uses", "uses", obj.getWrappedValue("relationship-list").getWrappedListValue("relationship").get(0).getValue("relationship-label"));
507 public void getVertexPropertiesRelationshipOldVersionNoEdgeLabelTest() throws AAIException, UnsupportedEncodingException {
509 Version version = Version.v11;
510 DBSerializer dbser = new DBSerializer(version, engine, introspectorFactoryType, "AAI-TEST");
511 Loader loader = LoaderFactory.createLoaderForVersion(introspectorFactoryType, version);
513 engine.startTransaction();
515 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","vnf-123");
516 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","vnfc-123");
517 EdgeRules rules = EdgeRules.getInstance();
518 rules.addEdge(engine.tx().traversal(), gvnf, vnfc);
520 Introspector obj = loader.introspectorFromName("generic-vnf");
521 obj = dbser.dbToObject(Arrays.asList(gvnf), obj, AAIProperties.MAXIMUM_DEPTH, false, "false");
523 assertEquals("Relationship does not contain edge-property", false, obj.getWrappedValue("relationship-list").getWrappedListValue("relationship").get(0).hasProperty("relationship-label"));
529 public void createEdgeWithValidLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
531 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
533 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
535 engine.startTransaction();
537 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
538 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
541 Introspector relData = loader.introspectorFromName("relationship-data");
542 relData.setValue("relationship-key", "vnfc.vnfc-name");
543 relData.setValue("relationship-value", "a-name");
544 Introspector relationship = loader.introspectorFromName("relationship");
545 relationship.setValue("related-to", "vnfc");
546 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
547 relationship.setValue("relationship-data",relData);
548 relationship.setValue("relationship-label", "over-uses");
550 assertTrue(localDbser.createEdge(relationship, gvnf));
551 assertTrue(engine.tx().traversal().V(gvnf).both("over-uses").hasNext());
552 assertTrue(engine.tx().traversal().V(vnfc).both("over-uses").hasNext());
557 public void createEdgeWithInvalidLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
559 engine.startTransaction();
561 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
562 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
564 Introspector relData = loader.introspectorFromName("relationship-data");
565 relData.setValue("relationship-key", "vnfc.vnfc-name");
566 relData.setValue("relationship-value", "a-name");
567 Introspector relationship = loader.introspectorFromName("relationship");
568 relationship.setValue("related-to", "vnfc");
569 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
570 relationship.setValue("relationship-data",relData);
571 relationship.setValue("relationship-label", "NA");
573 thrown.expect(AAIException.class);
574 thrown.expectMessage("no COUSIN edge rule between generic-vnf and vnfc with label NA");
576 dbser.createEdge(relationship, gvnf);
583 public void createEdgeWithValidLabelWhenSameEdgeExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
585 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
587 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
589 engine.startTransaction();
591 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
592 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
593 ers.addEdge(graph.traversal(), gvnf, vnfc, "re-uses");
595 Introspector relData = loader.introspectorFromName("relationship-data");
596 relData.setValue("relationship-key", "vnfc.vnfc-name");
597 relData.setValue("relationship-value", "a-name");
598 Introspector relationship = loader.introspectorFromName("relationship");
599 relationship.setValue("related-to", "vnfc");
600 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
601 relationship.setValue("relationship-data",relData);
602 relationship.setValue("relationship-label", "re-uses");
604 assertTrue(localDbser.createEdge(relationship, gvnf));
605 assertTrue(engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
606 assertTrue(engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
607 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V(vnfc).both().count().next());
612 public void createEdgeWithValidLabelWhenDiffEdgeExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
614 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
615 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
617 engine.startTransaction();
619 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
620 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
621 ers.addEdge(graph.traversal(), gvnf, vnfc, "uses");
623 Introspector relData = loader.introspectorFromName("relationship-data");
624 relData.setValue("relationship-key", "vnfc.vnfc-name");
625 relData.setValue("relationship-value", "a-name");
626 Introspector relationship = loader.introspectorFromName("relationship");
627 relationship.setValue("related-to", "vnfc");
628 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
629 relationship.setValue("relationship-data",relData);
630 relationship.setValue("relationship-label", "uses");
631 localDbser.createEdge(relationship, gvnf);
633 relationship.setValue("relationship-label", "re-uses");
635 assertTrue(localDbser.createEdge(relationship, gvnf));
636 assertTrue(engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
637 assertTrue(engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
638 assertTrue(engine.tx().traversal().V(gvnf).both("uses").hasNext());
639 assertTrue(engine.tx().traversal().V(vnfc).both("uses").hasNext());
640 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(vnfc).both().count().next());
641 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(gvnf).both().count().next());
646 public void createEdgeWithNoLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
648 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
649 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
651 engine.startTransaction();
653 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
654 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
656 Introspector relData = loader.introspectorFromName("relationship-data");
657 relData.setValue("relationship-key", "vnfc.vnfc-name");
658 relData.setValue("relationship-value", "a-name");
659 Introspector relationship = loader.introspectorFromName("relationship");
660 relationship.setValue("related-to", "vnfc");
661 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
662 relationship.setValue("relationship-data",relData);
663 localDbser.createEdge(relationship, gvnf);
665 assertTrue(localDbser.createEdge(relationship, gvnf));
666 assertTrue(engine.tx().traversal().V(gvnf).both("uses").hasNext());
667 assertTrue(engine.tx().traversal().V(vnfc).both("uses").hasNext());
668 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V(vnfc).both().count().next());
669 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V(gvnf).both().count().next());
675 public void deleteEdgeWithNoLabelWhenMultipleExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
677 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
679 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
681 engine.startTransaction();
683 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
684 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
685 ers.addEdge(graph.traversal(), gvnf, vnfc, "uses");
686 ers.addEdge(graph.traversal(), gvnf, vnfc, "re-uses");
687 ers.addEdge(graph.traversal(), gvnf, vnfc, "over-uses");
689 Introspector relData = loader.introspectorFromName("relationship-data");
690 relData.setValue("relationship-key", "vnfc.vnfc-name");
691 relData.setValue("relationship-value", "a-name");
692 Introspector relationship = loader.introspectorFromName("relationship");
693 relationship.setValue("related-to", "vnfc");
694 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
695 relationship.setValue("relationship-data",relData);
697 assertTrue(localDbser.deleteEdge(relationship, gvnf));
698 assertFalse("generic-vnf has no edge uses", engine.tx().traversal().V(gvnf).both("uses").hasNext());
699 assertFalse("vnfc has no edge uses", engine.tx().traversal().V(vnfc).both("uses").hasNext());
700 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
701 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
702 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V(gvnf).both("over-uses").hasNext());
703 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V(vnfc).both("over-uses").hasNext());
704 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(vnfc).both().count().next());
705 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(gvnf).both().count().next());
710 public void deleteEdgeWithValidLabelWhenMultipleExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
712 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
713 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
715 engine.startTransaction();
717 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
718 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
719 ers.addEdge(graph.traversal(), gvnf, vnfc, "uses");
720 ers.addEdge(graph.traversal(), gvnf, vnfc, "re-uses");
721 ers.addEdge(graph.traversal(), gvnf, vnfc, "over-uses");
723 Introspector relData = loader.introspectorFromName("relationship-data");
724 relData.setValue("relationship-key", "vnfc.vnfc-name");
725 relData.setValue("relationship-value", "a-name");
726 Introspector relationship = loader.introspectorFromName("relationship");
727 relationship.setValue("related-to", "vnfc");
728 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
729 relationship.setValue("relationship-data",relData);
730 relationship.setValue("relationship-label", "re-uses");
732 assertTrue(localDbser.deleteEdge(relationship, gvnf));
733 assertTrue("generic-vnf has edge uses", engine.tx().traversal().V(gvnf).both("uses").hasNext());
734 assertTrue("vnfc has edge uses", engine.tx().traversal().V(vnfc).both("uses").hasNext());
735 assertFalse("generic-vnf has no edge re-uses", engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
736 assertFalse("vnfc has no edge re-uses", engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
737 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V(gvnf).both("over-uses").hasNext());
738 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V(vnfc).both("over-uses").hasNext());
739 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(vnfc).both().count().next());
740 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(gvnf).both().count().next());
745 public void deleteEdgeWithValidInvalidLabelWhenMultipleExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
747 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
748 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
750 engine.startTransaction();
752 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
753 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
754 ers.addEdge(graph.traversal(), gvnf, vnfc, "uses");
755 ers.addEdge(graph.traversal(), gvnf, vnfc, "re-uses");
756 ers.addEdge(graph.traversal(), gvnf, vnfc, "over-uses");
758 Introspector relData = loader.introspectorFromName("relationship-data");
759 relData.setValue("relationship-key", "vnfc.vnfc-name");
760 relData.setValue("relationship-value", "a-name");
761 Introspector relationship = loader.introspectorFromName("relationship");
762 relationship.setValue("related-to", "vnfc");
763 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
764 relationship.setValue("relationship-data",relData);
765 relationship.setValue("relationship-label", "NA");
767 thrown.expect(AAIException.class);
768 thrown.expectMessage("no COUSIN edge rule between generic-vnf and vnfc with label NA");
770 localDbser.deleteEdge(relationship, gvnf);
777 public void serializeToDbWithLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
779 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
780 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
782 engine.startTransaction();
784 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
786 Introspector relationship = loader.introspectorFromName("relationship");
787 relationship.setValue("related-to", "vnfc");
788 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
789 relationship.setValue("relationship-label", "re-uses");
790 Introspector relationshipList = loader.introspectorFromName("relationship-list");
791 relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
793 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
794 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
795 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
796 gvnfObj.setValue("vnf-id", "myvnf");
798 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
800 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
802 assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
803 assertTrue("vertex with vnfc-name a-name exists", engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
804 assertFalse("generic-vnf has no edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
805 assertFalse("vnfc has no edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
806 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
807 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
808 assertFalse("generic-vnf has no edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
809 assertFalse("vnfc has no edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
810 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
811 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
816 public void serializeToDbWithoutLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
818 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
819 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
821 engine.startTransaction();
823 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
825 Introspector relationship = loader.introspectorFromName("relationship");
826 relationship.setValue("related-to", "vnfc");
827 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
829 Introspector relationshipList = loader.introspectorFromName("relationship-list");
830 relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
832 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
833 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
834 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
835 gvnfObj.setValue("vnf-id", "myvnf");
837 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
839 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
841 assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
842 assertTrue("vertex with vnfc-name a-name exists", engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
843 assertTrue("generic-vnf has edge uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
844 assertTrue("vnfc has edge uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
845 assertFalse("generic-vnf has no edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
846 assertFalse("vnfc has no edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
847 assertFalse("generic-vnf has no edge over-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
848 assertFalse("vnfc has no edge over-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
849 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
850 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
855 public void serializeToDbWithInvalidLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
857 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
858 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
860 engine.startTransaction();
862 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
864 Introspector relationship = loader.introspectorFromName("relationship");
865 relationship.setValue("related-to", "vnfc");
866 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
867 relationship.setValue("relationship-label", "NA");
868 Introspector relationshipList = loader.introspectorFromName("relationship-list");
869 relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
871 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
872 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
873 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
874 gvnfObj.setValue("vnf-id", "myvnf");
876 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
878 thrown.expect(AAIException.class);
879 thrown.expectMessage("No EdgeRule found for passed nodeTypes: generic-vnf, vnfc with label NA.");
881 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
889 public void serializeToDbWithLabelAndEdgeExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
891 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
892 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
894 engine.startTransaction();
895 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
897 Introspector relationship;
898 Introspector relationshipList;
899 List<Object> relList = new ArrayList<>();
901 // create generic-vnf
902 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
903 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
904 gvnfObj.setValue("vnf-id", "myvnf");
905 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
907 // create relationship to vnfc
908 relationship = loader.introspectorFromName("relationship");
909 relationship.setValue("related-to", "vnfc");
910 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
911 relList.add(relationship.getUnderlyingObject());
912 relationshipList = loader.introspectorFromName("relationship-list");
913 relationshipList.setValue("relationship", relList);
914 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
917 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
919 // add second relationship
920 relationship = loader.introspectorFromName("relationship");
921 relationship.setValue("related-to", "vnfc");
922 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
923 relationship.setValue("relationship-label", "re-uses");
924 relList.add(relationship.getUnderlyingObject());
925 relationshipList = loader.introspectorFromName("relationship-list");
926 relationshipList.setValue("relationship", relList);
927 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
929 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
931 assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
932 assertTrue("vertex with vnfc-name a-name exists", engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
933 assertTrue("generic-vnf has edge uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
934 assertTrue("vnfc has edge uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
935 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
936 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
937 assertFalse("generic-vnf has no edge over-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
938 assertFalse("vnfc has no edge over-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
939 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
940 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
945 public void serializeToDbWithLabelDroppingRelationshipTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
947 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
948 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
950 engine.startTransaction();
951 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
953 Introspector relationship;
954 Introspector relationshipList;
955 List<Object> relList = new ArrayList<>();
957 // create generic-vnf
958 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
959 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
960 gvnfObj.setValue("vnf-id", "myvnf");
961 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
963 // create relationship to vnfc
964 relationship = loader.introspectorFromName("relationship");
965 relationship.setValue("related-to", "vnfc");
966 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
967 relList.add(relationship.getUnderlyingObject());
968 // add second relationship
969 relationship = loader.introspectorFromName("relationship");
970 relationship.setValue("related-to", "vnfc");
971 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
972 relationship.setValue("relationship-label", "re-uses");
973 relList.add(relationship.getUnderlyingObject());
974 relationshipList = loader.introspectorFromName("relationship-list");
975 relationshipList.setValue("relationship", relList);
976 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
979 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
981 // drop second relationship
983 relationshipList = loader.introspectorFromName("relationship-list");
984 relationshipList.setValue("relationship", relList);
985 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
987 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
989 assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
990 assertTrue("vertex with vnfc-name a-name exists", engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
991 assertTrue("generic-vnf has edge uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
992 assertTrue("vnfc has edge uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
993 assertFalse("generic-vnf no longer has edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
994 assertFalse("vnfc no longer has edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
995 assertFalse("generic-vnf has no edge over-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
996 assertFalse("vnfc has no edge over-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
997 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
998 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
1002 private DBSerializer getDBSerializerWithSpecificEdgeRules(EdgeRules ers)
1003 throws NoSuchFieldException, AAIException, IllegalAccessException {
1004 // reflection to set the edge rules to the test one for DBSerializer
1005 Field reader = DBSerializer.class.getDeclaredField("edgeRules");
1006 reader.setAccessible(true);
1007 DBSerializer localDbser = new DBSerializer(Version.getLatest(), engine, introspectorFactoryType, "AAI-TEST");
1008 reader.set(localDbser, ers);