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.T;
42 import org.apache.tinkerpop.gremlin.structure.Vertex;
43 import org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerGraph;
44 import org.junit.After;
45 import org.junit.Before;
46 import org.junit.Rule;
47 import org.junit.Test;
48 import org.junit.rules.ExpectedException;
49 import org.onap.aai.AAISetup;
50 import org.onap.aai.db.props.AAIProperties;
51 import org.onap.aai.dbmap.DBConnectionType;
52 import org.onap.aai.exceptions.AAIException;
53 import org.onap.aai.introspection.Introspector;
54 import org.onap.aai.introspection.Loader;
55 import org.onap.aai.introspection.LoaderFactory;
56 import org.onap.aai.introspection.ModelType;
57 import org.onap.aai.introspection.Version;
58 import org.onap.aai.parsers.query.QueryParser;
59 import org.onap.aai.serialization.engines.QueryStyle;
60 import org.onap.aai.serialization.engines.TitanDBEngine;
61 import org.onap.aai.serialization.engines.TransactionalGraphEngine;
63 import com.thinkaurelius.titan.core.TitanFactory;
65 public class DbSerializerTest extends AAISetup {
67 //to use, set thrown.expect to whatever your test needs
68 //this line establishes default of expecting no exception to be thrown
70 public ExpectedException thrown = ExpectedException.none();
72 protected Graph graph;
73 protected final EdgeRules rules = EdgeRules.getInstance();
75 private final Version version = Version.getLatest();
76 private final ModelType introspectorFactoryType = ModelType.MOXY;
77 private final QueryStyle queryStyle = QueryStyle.TRAVERSAL;
78 private final DBConnectionType type = DBConnectionType.REALTIME;
79 private Loader loader;
80 private TransactionalGraphEngine dbEngine;
81 private TransactionalGraphEngine engine; //for tests that aren't mocking the engine
82 private DBSerializer dbser;
83 TransactionalGraphEngine spy;
84 TransactionalGraphEngine.Admin adminSpy;
87 public void setup() throws Exception {
88 graph = TitanFactory.build().set("storage.backend", "inmemory").open();
89 loader = LoaderFactory.createLoaderForVersion(introspectorFactoryType, version);
90 dbEngine = new TitanDBEngine(queryStyle, type, loader);
92 adminSpy = spy(dbEngine.asAdmin());
96 engine = new TitanDBEngine(queryStyle, type, loader);
97 dbser = new DBSerializer(version, engine, introspectorFactoryType, "AAI-TEST");
100 public void createGraph() throws AAIException {
102 * This setus up the test graph, For future junits , add more vertices
106 Vertex l3interipv4addresslist_1 = graph.traversal().addV("aai-node-type", "l3-interface-ipv4-address-list",
107 "l3-interface-ipv4-address", "l3-interface-ipv4-address-1").next();
108 Vertex subnet_2 = graph.traversal().addV("aai-node-type", "subnet", "subnet-id", "subnet-id-2").next();
109 Vertex l3interipv6addresslist_3 = graph.traversal().addV("aai-node-type", "l3-interface-ipv6-address-list",
110 "l3-interface-ipv6-address", "l3-interface-ipv6-address-3").next();
111 Vertex subnet_4 = graph.traversal().addV("aai-node-type", "subnet", "subnet-id", "subnet-id-4").next();
112 Vertex subnet_5 = graph.traversal().addV("aai-node-type", "subnet", "subnet-id", "subnet-id-5").next();
113 Vertex l3network_6 = graph.traversal()
114 .addV("aai-node-type", "l3-network", "network-id", "network-id-6", "network-name", "network-name-6")
117 GraphTraversalSource g = graph.traversal();
118 rules.addEdge(g, l3interipv4addresslist_1, subnet_2);
119 rules.addEdge(g, l3interipv6addresslist_3, subnet_4);
120 rules.addTreeEdge(g, subnet_5, l3network_6);
125 public void tearDown() throws Exception {
130 public void subnetDelwithInEdgesIpv4Test() throws AAIException {
131 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]";
134 * This subnet has in-edges with l3-ipv4 and NOT ok to delete
136 Vertex subnet = graph.traversal().V().has("aai-node-type", "subnet").has("subnet-id", "subnet-id-2").next();
138 String exceptionMessage = testDelete(subnet);
139 assertEquals(expected_message, exceptionMessage);
144 public void subnetDelwithInEdgesIpv6Test() throws AAIException {
145 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]";
148 * This subnet has in-edges with l3-ipv6 and NOT ok to delete
150 Vertex subnet = graph.traversal().V().has("aai-node-type", "subnet").has("subnet-id", "subnet-id-4").next();
151 String exceptionMessage = testDelete(subnet);
152 assertEquals(expected_message, exceptionMessage);
157 public void subnetDelwithInEdgesL3network() throws AAIException {
158 String expected_message = "";
161 * This subnet has in-edges with l3-network and ok to delete
163 Vertex subnet = graph.traversal().V().has("aai-node-type", "subnet").has("subnet-id", "subnet-id-5").next();
165 String exceptionMessage = testDelete(subnet);
166 assertEquals(expected_message, exceptionMessage);
170 public String testDelete(Vertex v) throws AAIException {
172 // Graph g_tx = graph.newTransaction();
173 GraphTraversalSource traversal = graph.traversal();
174 when(spy.asAdmin()).thenReturn(adminSpy);
175 when(adminSpy.getTraversalSource()).thenReturn(traversal);
176 when(adminSpy.getReadOnlyTraversalSource()).thenReturn(traversal);
178 String exceptionMessage = "";
179 DBSerializer serializer = new DBSerializer(version, spy, introspectorFactoryType, "AAI_TEST");
181 serializer.delete(v, "resourceVersion", false);
182 } catch (AAIException exception) {
183 exceptionMessage = exception.getMessage();
186 return exceptionMessage;
191 public void createNewVertexTest() throws AAIException {
192 engine.startTransaction();
194 Introspector testObj = loader.introspectorFromName("generic-vnf");
196 Vertex testVertex = dbser.createNewVertex(testObj);
197 Vertex fromGraph = engine.tx().traversal().V().has("aai-node-type","generic-vnf").toList().get(0);
198 assertEquals(testVertex.id(), fromGraph.id());
199 assertEquals("AAI-TEST", fromGraph.property(AAIProperties.SOURCE_OF_TRUTH.toString()).value());
204 public void touchStandardVertexPropertiesTest() throws AAIException, InterruptedException {
205 engine.startTransaction();
206 DBSerializer dbser2 = new DBSerializer(Version.getLatest(), engine, introspectorFactoryType, "AAI-TEST-2");
208 Graph graph = TinkerGraph.open();
209 Vertex vert = graph.addVertex("aai-node-type", "generic-vnf");
211 dbser.touchStandardVertexProperties(vert, true);
212 String resverStart = (String)vert.property(AAIProperties.RESOURCE_VERSION.toString()).value();
213 String lastModTimeStart = (String)vert.property(AAIProperties.LAST_MOD_TS.toString()).value();
215 Thread.sleep(10); //bc the resource version is set based on current time in milliseconds,
216 //if this test runs through too fast the value may not change
217 //causing the test to fail. sleeping ensures a different value
219 dbser2.touchStandardVertexProperties(vert, false);
220 assertFalse(resverStart.equals((String)vert.property(AAIProperties.RESOURCE_VERSION.toString()).value()));
221 assertFalse(lastModTimeStart.equals((String)vert.property(AAIProperties.LAST_MOD_TS.toString()).value()));
222 assertEquals("AAI-TEST-2", (String)vert.property(AAIProperties.LAST_MOD_SOURCE_OF_TRUTH.toString()).value());
227 public void verifyResourceVersion_SunnyDayTest() throws AAIException {
228 engine.startTransaction();
230 assertTrue(dbser.verifyResourceVersion("delete", "vnfc", "abc", "abc", "vnfcs/vnfc/vnfcId"));
235 public void verifyResourceVersion_CreateWithRVTest() throws AAIException {
236 engine.startTransaction();
238 thrown.expect(AAIException.class);
239 thrown.expectMessage("resource-version passed for create of generic-vnfs/generic-vnf/myid");
241 dbser.verifyResourceVersion("create", "generic-vnf", null, "old-res-ver", "generic-vnfs/generic-vnf/myid");
248 public void verifyResourceVersion_MissingRVTest() throws AAIException {
249 engine.startTransaction();
251 thrown.expect(AAIException.class);
252 thrown.expectMessage("resource-version not passed for update of generic-vnfs/generic-vnf/myid");
254 dbser.verifyResourceVersion("update", "generic-vnf", "current-res-ver", null, "generic-vnfs/generic-vnf/myid");
261 public void verifyResourceVersion_MismatchRVTest() throws AAIException {
262 engine.startTransaction();
264 thrown.expect(AAIException.class);
265 thrown.expectMessage("resource-version MISMATCH for update of generic-vnfs/generic-vnf/myid");
267 dbser.verifyResourceVersion("update", "generic-vnf", "current-res-ver", "old-res-ver", "generic-vnfs/generic-vnf/myid");
274 public void trimClassNameTest() throws AAIException {
275 assertEquals("GenericVnf", dbser.trimClassName("GenericVnf"));
276 assertEquals("GenericVnf", dbser.trimClassName("org.onap.aai.GenericVnf"));
280 public void getURIForVertexTest() throws AAIException, URISyntaxException, UnsupportedEncodingException {
281 engine.startTransaction();
283 Vertex cr = engine.tx().addVertex("aai-node-type", "cloud-region", "cloud-owner", "me", "cloud-region-id", "123");
284 Vertex ten = engine.tx().addVertex("aai-node-type", "tenant", "tenant-id", "453");
285 EdgeRules rules = EdgeRules.getInstance();
286 rules.addTreeEdge(engine.tx().traversal(), cr, ten);
288 URI compare = new URI("/cloud-infrastructure/cloud-regions/cloud-region/me/123/tenants/tenant/453");
289 assertEquals(compare, dbser.getURIForVertex(ten));
291 cr.property("aai-node-type").remove();
292 URI compareFailure = new URI("/unknown-uri");
293 assertEquals(compareFailure, dbser.getURIForVertex(ten));
298 public void getVertexPropertiesTest() throws AAIException, UnsupportedEncodingException {
299 engine.startTransaction();
301 Vertex cr = engine.tx().addVertex("aai-node-type", "cloud-region", "cloud-owner", "me", "cloud-region-id", "123");
303 Introspector crIntro = dbser.getVertexProperties(cr);
304 assertEquals("cloud-region", crIntro.getDbName());
305 assertEquals("me", crIntro.getValue("cloud-owner"));
306 assertEquals("123", crIntro.getValue("cloud-region-id"));
311 public void setCachedURIsTest() throws AAIException, UnsupportedEncodingException, URISyntaxException {
312 engine.startTransaction();
314 Vertex cr = engine.tx().addVertex("aai-node-type", "cloud-region", "cloud-owner", "me", "cloud-region-id", "123");
315 Vertex ten = engine.tx().addVertex("aai-node-type", "tenant", "tenant-id", "453");
316 Vertex vs = engine.tx().addVertex("aai-node-type", "vserver", "vserver-id", "vs1",
317 AAIProperties.AAI_URI.toString(),
318 "/cloud-infrastructure/cloud-regions/cloud-region/me/123/tenants/tenant/453/vservers/vserver/vs1");
319 EdgeRules rules = EdgeRules.getInstance();
320 rules.addTreeEdge(engine.tx().traversal(), cr, ten);
321 rules.addTreeEdge(engine.tx().traversal(), ten, vs);
323 List<Vertex> vertices = Arrays.asList(cr, ten, vs);
324 Introspector crIn = dbser.getVertexProperties(cr);
325 Introspector tenIn = dbser.getVertexProperties(ten);
326 Introspector vsIn = dbser.getVertexProperties(vs);
327 List<Introspector> intros = Arrays.asList(crIn, tenIn, vsIn);
329 dbser.setCachedURIs(vertices, intros);
331 assertEquals("/cloud-infrastructure/cloud-regions/cloud-region/me/123",
332 (String)cr.property(AAIProperties.AAI_URI.toString()).value());
333 assertEquals("/cloud-infrastructure/cloud-regions/cloud-region/me/123/tenants/tenant/453",
334 (String)ten.property(AAIProperties.AAI_URI.toString()).value());
335 assertEquals("/cloud-infrastructure/cloud-regions/cloud-region/me/123/tenants/tenant/453/vservers/vserver/vs1",
336 (String)vs.property(AAIProperties.AAI_URI.toString()).value());
341 public void getEdgeBetweenTest() throws AAIException {
342 engine.startTransaction();
344 Vertex cr = engine.tx().addVertex("aai-node-type", "cloud-region", "cloud-owner", "me", "cloud-region-id", "123");
345 Vertex ten = engine.tx().addVertex("aai-node-type", "tenant", "tenant-id", "453");
346 EdgeRules rules = EdgeRules.getInstance();
347 rules.addTreeEdge(engine.tx().traversal(), cr, ten);
349 Edge e = dbser.getEdgeBetween(EdgeType.TREE, ten, cr, null);
350 assertEquals("has", e.label());
355 public void deleteEdgeTest() throws AAIException, UnsupportedEncodingException {
356 engine.startTransaction();
358 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
359 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
360 EdgeRules rules = EdgeRules.getInstance();
361 rules.addEdge(engine.tx().traversal(), gvnf, vnfc);
363 Introspector relData = loader.introspectorFromName("relationship-data");
364 relData.setValue("relationship-key", "vnfc.vnfc-name");
365 relData.setValue("relationship-value", "a-name");
366 Introspector relationship = loader.introspectorFromName("relationship");
367 relationship.setValue("related-to", "vnfc");
368 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
369 relationship.setValue("relationship-data",relData);
371 assertTrue(dbser.deleteEdge(relationship, gvnf));
373 assertFalse(engine.tx().traversal().V(gvnf).both("uses").hasNext());
374 assertFalse(engine.tx().traversal().V(vnfc).both("uses").hasNext());
379 public void createEdgeTest() throws AAIException, UnsupportedEncodingException {
380 engine.startTransaction();
382 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
383 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
386 Introspector relData = loader.introspectorFromName("relationship-data");
387 relData.setValue("relationship-key", "vnfc.vnfc-name");
388 relData.setValue("relationship-value", "a-name");
389 Introspector relationship = loader.introspectorFromName("relationship");
390 relationship.setValue("related-to", "vnfc");
391 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
392 relationship.setValue("relationship-data",relData);
394 assertTrue(dbser.createEdge(relationship, gvnf));
395 assertTrue(engine.tx().traversal().V(gvnf).both("uses").hasNext());
396 assertTrue(engine.tx().traversal().V(vnfc).both("uses").hasNext());
401 public void createCousinEdgeThatShouldBeTreeTest() throws AAIException, UnsupportedEncodingException, URISyntaxException {
402 engine.startTransaction();
404 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
405 Vertex vf = engine.tx().addVertex("aai-node-type","vf-module","vf-module-id","vf-id");
407 EdgeRules.getInstance().addTreeEdge(engine.tx().traversal(), gvnf, vf);
409 Introspector relationship = loader.introspectorFromName("relationship");
410 relationship.setValue("related-to", "vf-module");
411 relationship.setValue("related-link", dbser.getURIForVertex(vf).toString());
412 //relationship.setValue("relationship-label", "");
413 Introspector relationshipList = loader.introspectorFromName("relationship-list");
414 relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
416 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
417 Vertex gvnf2 = dbser.createNewVertex(gvnfObj);
418 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
419 gvnfObj.setValue("vnf-id", "myvnf-1");
421 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf-1"));
424 dbser.serializeToDb(gvnfObj, gvnf2, uriQuery, null, "test");
425 } catch (AAIException e) {
426 assertEquals("AAI_6145", e.getCode());
434 public void createEdgeNodeDoesNotExistExceptionTest() throws AAIException, UnsupportedEncodingException {
435 engine.startTransaction();
437 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
439 //rainy day case, edge to non-existent object
440 Introspector relData = loader.introspectorFromName("relationship-data");
441 relData.setValue("relationship-key", "vnfc.vnfc-name");
442 relData.setValue("relationship-value", "b-name");
443 Introspector relationship = loader.introspectorFromName("relationship");
444 relationship.setValue("related-to", "vnfc");
445 relationship.setValue("related-link", "/network/vnfcs/vnfc/b-name");
446 relationship.setValue("relationship-data",relData);
448 thrown.expect(AAIException.class);
449 thrown.expectMessage("Node of type vnfc. Could not find object at: /network/vnfcs/vnfc/b-name");
451 dbser.createEdge(relationship, gvnf);
458 public void serializeSingleVertexTopLevelTest() throws AAIException, UnsupportedEncodingException {
459 engine.startTransaction();
461 Introspector gvnf = loader.introspectorFromName("generic-vnf");
462 Vertex gvnfVert = dbser.createNewVertex(gvnf);
464 gvnf.setValue("vnf-id", "myvnf");
465 dbser.serializeSingleVertex(gvnfVert, gvnf, "test");
466 assertTrue(engine.tx().traversal().V().has("aai-node-type","generic-vnf").has("vnf-id","myvnf").hasNext());
471 public void serializeSingleVertexChildTest() throws AAIException, UnsupportedEncodingException {
472 engine.startTransaction();
474 Vertex cr = engine.tx().addVertex("aai-node-type", "cloud-region", "cloud-owner", "me", "cloud-region-id", "123");
475 Introspector tenIn = loader.introspectorFromName("tenant");
476 Vertex ten = dbser.createNewVertex(tenIn);
477 EdgeRules rules = EdgeRules.getInstance();
478 rules.addTreeEdge(engine.tx().traversal(), cr, ten);
480 tenIn.setValue("tenant-id", "453");
481 tenIn.setValue("tenant-name", "mytenant");
483 dbser.serializeSingleVertex(ten, tenIn, "test");
485 assertTrue(engine.tx().traversal().V().has("aai-node-type","tenant").has("tenant-id","453").has("tenant-name","mytenant").hasNext());
491 public void getVertexPropertiesRelationshipHasLabelTest() throws AAIException, UnsupportedEncodingException {
492 engine.startTransaction();
494 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","vnf-123");
495 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","vnfc-123");
496 EdgeRules rules = EdgeRules.getInstance();
497 rules.addEdge(engine.tx().traversal(), gvnf, vnfc);
499 Introspector obj = loader.introspectorFromName("generic-vnf");
500 obj = this.dbser.dbToObject(Arrays.asList(gvnf), obj, AAIProperties.MAXIMUM_DEPTH, false, "false");
502 assertEquals("edge label between generic-vnf and vnfs is uses", "uses", obj.getWrappedValue("relationship-list").getWrappedListValue("relationship").get(0).getValue("relationship-label"));
508 public void getVertexPropertiesRelationshipOldVersionNoEdgeLabelTest() throws AAIException, UnsupportedEncodingException {
510 Version version = Version.v11;
511 DBSerializer dbser = new DBSerializer(version, engine, introspectorFactoryType, "AAI-TEST");
512 Loader loader = LoaderFactory.createLoaderForVersion(introspectorFactoryType, version);
514 engine.startTransaction();
516 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","vnf-123");
517 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","vnfc-123");
518 EdgeRules rules = EdgeRules.getInstance();
519 rules.addEdge(engine.tx().traversal(), gvnf, vnfc);
521 Introspector obj = loader.introspectorFromName("generic-vnf");
522 obj = dbser.dbToObject(Arrays.asList(gvnf), obj, AAIProperties.MAXIMUM_DEPTH, false, "false");
524 assertEquals("Relationship does not contain edge-property", false, obj.getWrappedValue("relationship-list").getWrappedListValue("relationship").get(0).hasProperty("relationship-label"));
530 public void createEdgeWithValidLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
532 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
534 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
536 engine.startTransaction();
538 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
539 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
542 Introspector relData = loader.introspectorFromName("relationship-data");
543 relData.setValue("relationship-key", "vnfc.vnfc-name");
544 relData.setValue("relationship-value", "a-name");
545 Introspector relationship = loader.introspectorFromName("relationship");
546 relationship.setValue("related-to", "vnfc");
547 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
548 relationship.setValue("relationship-data",relData);
549 relationship.setValue("relationship-label", "over-uses");
551 assertTrue(localDbser.createEdge(relationship, gvnf));
552 assertTrue(engine.tx().traversal().V(gvnf).both("over-uses").hasNext());
553 assertTrue(engine.tx().traversal().V(vnfc).both("over-uses").hasNext());
558 public void createEdgeWithInvalidLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
560 engine.startTransaction();
562 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
563 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
565 Introspector relData = loader.introspectorFromName("relationship-data");
566 relData.setValue("relationship-key", "vnfc.vnfc-name");
567 relData.setValue("relationship-value", "a-name");
568 Introspector relationship = loader.introspectorFromName("relationship");
569 relationship.setValue("related-to", "vnfc");
570 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
571 relationship.setValue("relationship-data",relData);
572 relationship.setValue("relationship-label", "NA");
574 thrown.expect(AAIException.class);
575 thrown.expectMessage("no COUSIN edge rule between generic-vnf and vnfc with label NA");
577 dbser.createEdge(relationship, gvnf);
584 public void createEdgeWithValidLabelWhenSameEdgeExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
586 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
588 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
590 engine.startTransaction();
592 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
593 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
594 ers.addEdge(graph.traversal(), gvnf, vnfc, "re-uses");
596 Introspector relData = loader.introspectorFromName("relationship-data");
597 relData.setValue("relationship-key", "vnfc.vnfc-name");
598 relData.setValue("relationship-value", "a-name");
599 Introspector relationship = loader.introspectorFromName("relationship");
600 relationship.setValue("related-to", "vnfc");
601 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
602 relationship.setValue("relationship-data",relData);
603 relationship.setValue("relationship-label", "re-uses");
605 assertTrue(localDbser.createEdge(relationship, gvnf));
606 assertTrue(engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
607 assertTrue(engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
608 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V(vnfc).both().count().next());
613 public void createEdgeWithValidLabelWhenDiffEdgeExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
615 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
616 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
618 engine.startTransaction();
620 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
621 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
622 ers.addEdge(graph.traversal(), gvnf, vnfc, "uses");
624 Introspector relData = loader.introspectorFromName("relationship-data");
625 relData.setValue("relationship-key", "vnfc.vnfc-name");
626 relData.setValue("relationship-value", "a-name");
627 Introspector relationship = loader.introspectorFromName("relationship");
628 relationship.setValue("related-to", "vnfc");
629 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
630 relationship.setValue("relationship-data",relData);
631 relationship.setValue("relationship-label", "uses");
632 localDbser.createEdge(relationship, gvnf);
634 relationship.setValue("relationship-label", "re-uses");
636 assertTrue(localDbser.createEdge(relationship, gvnf));
637 assertTrue(engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
638 assertTrue(engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
639 assertTrue(engine.tx().traversal().V(gvnf).both("uses").hasNext());
640 assertTrue(engine.tx().traversal().V(vnfc).both("uses").hasNext());
641 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(vnfc).both().count().next());
642 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(gvnf).both().count().next());
647 public void createEdgeWithNoLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
649 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
650 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
652 engine.startTransaction();
654 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
655 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
657 Introspector relData = loader.introspectorFromName("relationship-data");
658 relData.setValue("relationship-key", "vnfc.vnfc-name");
659 relData.setValue("relationship-value", "a-name");
660 Introspector relationship = loader.introspectorFromName("relationship");
661 relationship.setValue("related-to", "vnfc");
662 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
663 relationship.setValue("relationship-data",relData);
664 localDbser.createEdge(relationship, gvnf);
666 assertTrue(localDbser.createEdge(relationship, gvnf));
667 assertTrue(engine.tx().traversal().V(gvnf).both("uses").hasNext());
668 assertTrue(engine.tx().traversal().V(vnfc).both("uses").hasNext());
669 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V(vnfc).both().count().next());
670 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V(gvnf).both().count().next());
676 public void deleteEdgeWithNoLabelWhenMultipleExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
678 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
680 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
682 engine.startTransaction();
684 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
685 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
686 ers.addEdge(graph.traversal(), gvnf, vnfc, "uses");
687 ers.addEdge(graph.traversal(), gvnf, vnfc, "re-uses");
688 ers.addEdge(graph.traversal(), gvnf, vnfc, "over-uses");
690 Introspector relData = loader.introspectorFromName("relationship-data");
691 relData.setValue("relationship-key", "vnfc.vnfc-name");
692 relData.setValue("relationship-value", "a-name");
693 Introspector relationship = loader.introspectorFromName("relationship");
694 relationship.setValue("related-to", "vnfc");
695 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
696 relationship.setValue("relationship-data",relData);
698 assertTrue(localDbser.deleteEdge(relationship, gvnf));
699 assertFalse("generic-vnf has no edge uses", engine.tx().traversal().V(gvnf).both("uses").hasNext());
700 assertFalse("vnfc has no edge uses", engine.tx().traversal().V(vnfc).both("uses").hasNext());
701 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
702 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
703 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V(gvnf).both("over-uses").hasNext());
704 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V(vnfc).both("over-uses").hasNext());
705 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(vnfc).both().count().next());
706 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(gvnf).both().count().next());
711 public void deleteEdgeWithValidLabelWhenMultipleExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
713 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
714 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
716 engine.startTransaction();
718 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
719 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
720 ers.addEdge(graph.traversal(), gvnf, vnfc, "uses");
721 ers.addEdge(graph.traversal(), gvnf, vnfc, "re-uses");
722 ers.addEdge(graph.traversal(), gvnf, vnfc, "over-uses");
724 Introspector relData = loader.introspectorFromName("relationship-data");
725 relData.setValue("relationship-key", "vnfc.vnfc-name");
726 relData.setValue("relationship-value", "a-name");
727 Introspector relationship = loader.introspectorFromName("relationship");
728 relationship.setValue("related-to", "vnfc");
729 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
730 relationship.setValue("relationship-data",relData);
731 relationship.setValue("relationship-label", "re-uses");
733 assertTrue(localDbser.deleteEdge(relationship, gvnf));
734 assertTrue("generic-vnf has edge uses", engine.tx().traversal().V(gvnf).both("uses").hasNext());
735 assertTrue("vnfc has edge uses", engine.tx().traversal().V(vnfc).both("uses").hasNext());
736 assertFalse("generic-vnf has no edge re-uses", engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
737 assertFalse("vnfc has no edge re-uses", engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
738 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V(gvnf).both("over-uses").hasNext());
739 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V(vnfc).both("over-uses").hasNext());
740 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(vnfc).both().count().next());
741 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(gvnf).both().count().next());
746 public void deleteEdgeWithValidInvalidLabelWhenMultipleExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
748 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
749 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
751 engine.startTransaction();
753 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
754 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
755 ers.addEdge(graph.traversal(), gvnf, vnfc, "uses");
756 ers.addEdge(graph.traversal(), gvnf, vnfc, "re-uses");
757 ers.addEdge(graph.traversal(), gvnf, vnfc, "over-uses");
759 Introspector relData = loader.introspectorFromName("relationship-data");
760 relData.setValue("relationship-key", "vnfc.vnfc-name");
761 relData.setValue("relationship-value", "a-name");
762 Introspector relationship = loader.introspectorFromName("relationship");
763 relationship.setValue("related-to", "vnfc");
764 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
765 relationship.setValue("relationship-data",relData);
766 relationship.setValue("relationship-label", "NA");
768 thrown.expect(AAIException.class);
769 thrown.expectMessage("no COUSIN edge rule between generic-vnf and vnfc with label NA");
771 localDbser.deleteEdge(relationship, gvnf);
778 public void serializeToDbWithLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
780 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
781 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
783 engine.startTransaction();
785 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
787 Introspector relationship = loader.introspectorFromName("relationship");
788 relationship.setValue("related-to", "vnfc");
789 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
790 relationship.setValue("relationship-label", "re-uses");
791 Introspector relationshipList = loader.introspectorFromName("relationship-list");
792 relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
794 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
795 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
796 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
797 gvnfObj.setValue("vnf-id", "myvnf");
799 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
801 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
803 assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
804 assertTrue("vertex with vnfc-name a-name exists", engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
805 assertFalse("generic-vnf has no edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
806 assertFalse("vnfc has no edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
807 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
808 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
809 assertFalse("generic-vnf has no edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
810 assertFalse("vnfc has no edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
811 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
812 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
817 public void serializeToDbWithoutLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
819 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
820 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
822 engine.startTransaction();
824 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
826 Introspector relationship = loader.introspectorFromName("relationship");
827 relationship.setValue("related-to", "vnfc");
828 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
830 Introspector relationshipList = loader.introspectorFromName("relationship-list");
831 relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
833 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
834 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
835 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
836 gvnfObj.setValue("vnf-id", "myvnf");
838 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
840 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
842 assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
843 assertTrue("vertex with vnfc-name a-name exists", engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
844 assertTrue("generic-vnf has edge uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
845 assertTrue("vnfc has edge uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
846 assertFalse("generic-vnf has no edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
847 assertFalse("vnfc has no edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
848 assertFalse("generic-vnf has no edge over-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
849 assertFalse("vnfc has no edge over-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
850 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
851 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
856 public void serializeToDbWithInvalidLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
858 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
859 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
861 engine.startTransaction();
863 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
865 Introspector relationship = loader.introspectorFromName("relationship");
866 relationship.setValue("related-to", "vnfc");
867 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
868 relationship.setValue("relationship-label", "NA");
869 Introspector relationshipList = loader.introspectorFromName("relationship-list");
870 relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
872 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
873 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
874 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
875 gvnfObj.setValue("vnf-id", "myvnf");
877 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
879 thrown.expect(AAIException.class);
880 thrown.expectMessage("No EdgeRule found for passed nodeTypes: generic-vnf, vnfc with label NA.");
882 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
890 public void serializeToDbWithLabelAndEdgeExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
892 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
893 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
895 engine.startTransaction();
896 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
898 Introspector relationship;
899 Introspector relationshipList;
900 List<Object> relList = new ArrayList<>();
902 // create generic-vnf
903 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
904 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
905 gvnfObj.setValue("vnf-id", "myvnf");
906 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
908 // create relationship to vnfc
909 relationship = loader.introspectorFromName("relationship");
910 relationship.setValue("related-to", "vnfc");
911 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
912 relList.add(relationship.getUnderlyingObject());
913 relationshipList = loader.introspectorFromName("relationship-list");
914 relationshipList.setValue("relationship", relList);
915 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
918 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
920 // add second relationship
921 relationship = loader.introspectorFromName("relationship");
922 relationship.setValue("related-to", "vnfc");
923 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
924 relationship.setValue("relationship-label", "re-uses");
925 relList.add(relationship.getUnderlyingObject());
926 relationshipList = loader.introspectorFromName("relationship-list");
927 relationshipList.setValue("relationship", relList);
928 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
930 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
932 assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
933 assertTrue("vertex with vnfc-name a-name exists", engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
934 assertTrue("generic-vnf has edge uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
935 assertTrue("vnfc has edge uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
936 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
937 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
938 assertFalse("generic-vnf has no edge over-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
939 assertFalse("vnfc has no edge over-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
940 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
941 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
946 public void serializeToDbWithLabelDroppingRelationshipTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
948 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
949 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
951 engine.startTransaction();
952 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
954 Introspector relationship;
955 Introspector relationshipList;
956 List<Object> relList = new ArrayList<>();
958 // create generic-vnf
959 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
960 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
961 gvnfObj.setValue("vnf-id", "myvnf");
962 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
964 // create relationship to vnfc
965 relationship = loader.introspectorFromName("relationship");
966 relationship.setValue("related-to", "vnfc");
967 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
968 relList.add(relationship.getUnderlyingObject());
969 // add second relationship
970 relationship = loader.introspectorFromName("relationship");
971 relationship.setValue("related-to", "vnfc");
972 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
973 relationship.setValue("relationship-label", "re-uses");
974 relList.add(relationship.getUnderlyingObject());
975 relationshipList = loader.introspectorFromName("relationship-list");
976 relationshipList.setValue("relationship", relList);
977 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
980 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
982 // drop second relationship
984 relationshipList = loader.introspectorFromName("relationship-list");
985 relationshipList.setValue("relationship", relList);
986 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
988 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
990 assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
991 assertTrue("vertex with vnfc-name a-name exists", engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
992 assertTrue("generic-vnf has edge uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
993 assertTrue("vnfc has edge uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
994 assertFalse("generic-vnf no longer has edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
995 assertFalse("vnfc no longer has edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
996 assertFalse("generic-vnf has no edge over-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
997 assertFalse("vnfc has no edge over-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
998 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
999 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
1003 private DBSerializer getDBSerializerWithSpecificEdgeRules(EdgeRules ers)
1004 throws NoSuchFieldException, AAIException, IllegalAccessException {
1005 // reflection to set the edge rules to the test one for DBSerializer
1006 Field reader = DBSerializer.class.getDeclaredField("edgeRules");
1007 reader.setAccessible(true);
1008 DBSerializer localDbser = new DBSerializer(Version.getLatest(), engine, introspectorFactoryType, "AAI-TEST");
1009 reader.set(localDbser, ers);
1014 public void addRelatedToPropertyTest() throws AAIException {
1015 Loader loader = LoaderFactory.createLoaderForVersion(ModelType.MOXY, Version.v11);
1016 Introspector gv = loader.introspectorFromName("generic-vnf");
1017 gv.setValue("vnf-name", "myname");
1018 Introspector rel = loader.introspectorFromName("relationship");
1019 DBSerializer dbser = new DBSerializer(Version.v11, dbEngine,
1020 ModelType.MOXY, "AAI-TEST");
1022 dbser.addRelatedToProperty(rel, gv);
1023 List<Introspector> relToProps = rel.getWrappedListValue("related-to-property");
1024 assertTrue(relToProps.size() == 1);
1025 Introspector relToProp = relToProps.get(0);
1026 assertTrue("generic-vnf.vnf-name".equals(relToProp.getValue("property-key")));
1027 assertTrue("myname".equals(relToProp.getValue("property-value")));
1031 public void dbToObjectContainerMismatchTest() throws AAIException, UnsupportedEncodingException {
1032 DBSerializer dbser = new DBSerializer(Version.v11, dbEngine,
1033 ModelType.MOXY, "AAI-TEST");
1035 Graph vertexMaker = TinkerGraph.open();
1036 Vertex a = vertexMaker.addVertex(T.id, "0");
1037 Vertex b = vertexMaker.addVertex(T.id, "1");
1038 List<Vertex> vertices = Arrays.asList(a,b);
1040 Loader loader = LoaderFactory.createLoaderForVersion(ModelType.MOXY, Version.v11);
1041 Introspector intro = loader.introspectorFromName("image"); //just need any non-container object
1043 thrown.expect(AAIException.class);
1044 thrown.expectMessage("query object mismatch: this object cannot hold multiple items.");
1046 dbser.dbToObject(vertices, intro, Integer.MAX_VALUE, true, "doesn't matter");
1050 public void dbToObjectTest() throws AAIException, UnsupportedEncodingException {
1051 engine.startTransaction();
1053 DBSerializer dbser = new DBSerializer(Version.getLatest(), engine,
1054 ModelType.MOXY, "AAI-TEST");
1056 Vertex gv1 = engine.tx().addVertex("aai-node-type", "generic-vnf", "vnf-id", "id1");
1057 Vertex gv2 = engine.tx().addVertex("aai-node-type", "generic-vnf", "vnf-id", "id2");
1058 List<Vertex> vertices = Arrays.asList(gv1, gv2);
1060 Loader loader = LoaderFactory.createLoaderForVersion(ModelType.MOXY, Version.getLatest());
1061 Introspector gvContainer = loader.introspectorFromName("generic-vnfs");
1063 Introspector res = dbser.dbToObject(vertices, gvContainer, 0, true, "true");
1064 List<Introspector> gvs = res.getWrappedListValue("generic-vnf");
1065 assertTrue(gvs.size() == 2);
1066 for (Introspector i : gvs) {
1067 String vnfId = i.getValue("vnf-id");
1068 assertTrue("id1".equals(vnfId) || "id2".equals(vnfId));
1075 public void getEdgeBetweenNoLabelTest() throws AAIException {
1076 DBSerializer dbser = new DBSerializer(Version.getLatest(), engine,
1077 ModelType.MOXY, "AAI-TEST");
1079 engine.startTransaction();
1080 Vertex gv = engine.tx().addVertex("aai-node-type", "generic-vnf", "vnf-id", "id1");
1081 Vertex lint = engine.tx().addVertex("aai-node-type", "l-interface", "interface-name", "name1");
1082 rules.addTreeEdge(engine.tx().traversal(), gv, lint);
1084 Edge res = dbser.getEdgeBetween(EdgeType.TREE, gv, lint);
1085 assertTrue("hasLInterface".equals(res.label()));
1090 public void deleteItemsWithTraversal() throws AAIException {
1091 DBSerializer dbser = new DBSerializer(Version.getLatest(), engine,
1092 ModelType.MOXY, "AAI-TEST");
1094 engine.startTransaction();
1095 Vertex gv = engine.tx().addVertex("aai-node-type", "generic-vnf", "vnf-id", "id1");
1096 Vertex lint = engine.tx().addVertex("aai-node-type", "l-interface", "interface-name", "name1");
1098 assertTrue(engine.tx().traversal().V().has("vnf-id", "id1").hasNext());
1099 assertTrue(engine.tx().traversal().V().has("interface-name", "name1").hasNext());
1101 dbser.deleteItemsWithTraversal(Arrays.asList(gv, lint));
1103 assertTrue(!engine.tx().traversal().V().has("vnf-id", "id1").hasNext());
1104 assertTrue(!engine.tx().traversal().V().has("interface-name", "name1").hasNext());
1110 public void serializeToDbWithParentTest() throws AAIException, UnsupportedEncodingException, URISyntaxException {
1111 DBSerializer dbser = new DBSerializer(Version.getLatest(), engine,
1112 ModelType.MOXY, "AAI-TEST");
1114 engine.startTransaction();
1115 Vertex gv = engine.tx().addVertex("aai-node-type", "generic-vnf", "vnf-id", "id1");
1116 Vertex lint = engine.tx().addVertex("aai-node-type", "l-interface", "interface-name", "name1");
1117 rules.addTreeEdge(engine.tx().traversal(), gv, lint);
1119 Introspector lintIntro = loader.introspectorFromName("l-interface");
1120 lintIntro.setValue("interface-role", "actor");
1121 URI lintURI = new URI("/network/generic-vnfs/generic-vnf/id1/l-interfaces/l-interface/name1");
1122 QueryParser uriQuery = dbEngine.getQueryBuilder(gv).createQueryFromURI(lintURI);
1123 dbser.serializeToDb(lintIntro, lint, uriQuery, "test-identifier", "AAI-TEST");
1125 assertTrue(engine.tx().traversal().V(lint).has("interface-role", "actor").hasNext());
1131 public void getLatestVersionViewTest() throws AAIException, UnsupportedEncodingException {
1132 DBSerializer dbser = new DBSerializer(Version.getLatest(), engine,
1133 ModelType.MOXY, "AAI-TEST");
1135 engine.startTransaction();
1136 Vertex phys = engine.tx().addVertex("aai-node-type", "physical-link", "link-name", "zaldo",
1137 "speed-value", "very-fast", "service-provider-bandwidth-up-units", "things");
1139 Introspector res = dbser.getLatestVersionView(phys);
1140 assertTrue("zaldo".equals(res.getValue("link-name")));
1141 assertTrue("very-fast".equals(res.getValue("speed-value")));
1142 assertTrue("things".equals(res.getValue("service-provider-bandwidth-up-units")));