2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright © 2017-18 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=========================================================
20 package org.onap.aai.serialization.db;
22 import org.onap.aai.setup.SchemaVersion;
23 import org.onap.aai.setup.SchemaVersions;
24 import org.onap.aai.util.AAIConstants;
25 import org.janusgraph.core.JanusGraphFactory;
26 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
27 import org.apache.tinkerpop.gremlin.structure.*;
29 import org.junit.rules.ExpectedException;
30 import org.junit.runner.RunWith;
31 import org.onap.aai.config.IntrospectionConfig;
32 import org.onap.aai.config.SpringContextAware;
33 import org.onap.aai.db.props.AAIProperties;
34 import org.onap.aai.dbmap.DBConnectionType;
35 import org.onap.aai.edges.EdgeIngestor;
36 import org.onap.aai.exceptions.AAIException;
37 import org.onap.aai.introspection.*;
38 import org.onap.aai.nodes.NodeIngestor;
39 import org.onap.aai.parsers.query.QueryParser;
40 import org.onap.aai.serialization.engines.QueryStyle;
41 import org.onap.aai.serialization.engines.JanusGraphDBEngine;
42 import org.onap.aai.serialization.engines.TransactionalGraphEngine;
43 import org.onap.aai.serialization.queryformats.QueryFormatTestHelper;
44 import org.onap.aai.setup.SchemaLocationsBean;
45 import org.springframework.beans.factory.annotation.Autowired;
46 import org.springframework.test.context.ContextConfiguration;
47 import org.springframework.test.context.TestPropertySource;
48 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
50 import java.io.UnsupportedEncodingException;
52 import java.net.URISyntaxException;
55 import static org.junit.Assert.*;
56 import static org.mockito.Mockito.spy;
57 import static org.mockito.Mockito.when;
59 //@RunWith(value = Parameterized.class) TODO replace this functionality
60 @RunWith(SpringJUnit4ClassRunner.class)
61 @ContextConfiguration(classes = {
62 SchemaLocationsBean.class,
64 AAICoreFakeEdgesConfigTranslator.class,
68 SpringContextAware.class,
69 IntrospectionConfig.class
71 @TestPropertySource(properties = {
72 "schema.translator.list = config"
74 public class DbSerializer_needsFakeRulesTest {
76 //to use, set thrown.expect to whatever your test needs
77 //this line establishes default of expecting no exception to be thrown
79 public ExpectedException thrown = ExpectedException.none();
81 protected static Graph graph;
84 protected EdgeSerializer edgeSer;
86 protected EdgeIngestor ei;
88 protected SchemaVersions schemaVersions;
90 private SchemaVersion version;
91 private final ModelType introspectorFactoryType = ModelType.MOXY;
92 private final DBConnectionType type = DBConnectionType.REALTIME;
93 private Loader loader;
94 private TransactionalGraphEngine dbEngine;
95 private TransactionalGraphEngine engine; //for tests that aren't mocking the engine
96 private DBSerializer dbser;
97 TransactionalGraphEngine spy;
98 TransactionalGraphEngine.Admin adminSpy;
100 //@Parameterized.Parameter(value = 0)
101 public QueryStyle queryStyle = QueryStyle.TRAVERSAL;
103 /*@Parameterized.Parameters(name = "QueryStyle.{0}")
104 public static Collection<Object[]> data() {
105 return Arrays.asList(new Object[][]{
106 {QueryStyle.TRAVERSAL},
107 {QueryStyle.TRAVERSAL_URI}
112 public static void init() throws Exception {
113 graph = JanusGraphFactory.build().set("storage.backend", "inmemory").open();
114 System.setProperty("AJSC_HOME", ".");
115 System.setProperty("BUNDLECONFIG_DIR", "src/test/resources/bundleconfig-local");
116 QueryFormatTestHelper.setFinalStatic(AAIConstants.class.getField("AAI_HOME_ETC_OXM"), "src/test/resources/bundleconfig-local/etc/oxm/");
121 public void setup() throws Exception {
123 version = schemaVersions.getDefaultVersion();
124 loader = SpringContextAware.getBean(LoaderFactory.class).createLoaderForVersion(introspectorFactoryType, version);
125 dbEngine = new JanusGraphDBEngine(queryStyle, type, loader);
127 adminSpy = spy(dbEngine.asAdmin());
130 engine = new JanusGraphDBEngine(queryStyle, type, loader);
131 dbser = new DBSerializer(version, engine, introspectorFactoryType, "AAI-TEST");
135 public void tearDown() throws Exception {
140 public static void destroy() throws Exception {
144 public void subnetSetup() throws AAIException {
146 * This setus up the test graph, For future junits , add more vertices
150 Vertex l3interipv4addresslist_1 = graph.traversal().addV("aai-node-type", "l3-interface-ipv4-address-list",
151 "l3-interface-ipv4-address", "l3-interface-ipv4-address-1").next();
152 Vertex subnet_2 = graph.traversal().addV("aai-node-type", "subnet", "subnet-id", "subnet-id-2").next();
153 Vertex l3interipv6addresslist_3 = graph.traversal().addV("aai-node-type", "l3-interface-ipv6-address-list",
154 "l3-interface-ipv6-address", "l3-interface-ipv6-address-3").next();
155 Vertex subnet_4 = graph.traversal().addV("aai-node-type", "subnet", "subnet-id", "subnet-id-4").next();
156 Vertex subnet_5 = graph.traversal().addV("aai-node-type", "subnet", "subnet-id", "subnet-id-5").next();
157 Vertex l3network_6 = graph.traversal()
158 .addV("aai-node-type", "l3-network", "network-id", "network-id-6", "network-name", "network-name-6")
161 GraphTraversalSource g = graph.traversal();
162 edgeSer.addEdge(g, l3interipv4addresslist_1, subnet_2);
163 edgeSer.addEdge(g, l3interipv6addresslist_3, subnet_4);
164 edgeSer.addTreeEdge(g, subnet_5, l3network_6);
167 public String testDelete(Vertex v) throws AAIException {
169 GraphTraversalSource traversal = graph.traversal();
170 when(spy.asAdmin()).thenReturn(adminSpy);
171 when(adminSpy.getTraversalSource()).thenReturn(traversal);
172 when(adminSpy.getReadOnlyTraversalSource()).thenReturn(traversal);
174 String exceptionMessage = "";
175 DBSerializer serializer = new DBSerializer(version, spy, introspectorFactoryType, "AAI_TEST");
177 serializer.delete(v, "resourceVersion", false);
178 } catch (AAIException exception) {
179 exceptionMessage = exception.getMessage();
181 return exceptionMessage;
186 public void serializeToDbNewVertexAndEdgeAAIUUIDTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
187 String testName = new Object() {}.getClass().getEnclosingMethod().getName();
188 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
190 engine.startTransaction();
192 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","vnfc-" + testName, AAIProperties.AAI_URI, "/network/vnfcs/vnfc/vnfc-" + testName);
194 Introspector relationship = loader.introspectorFromName("relationship");
195 relationship.setValue("related-to", "vnfc");
196 relationship.setValue("related-link", "/network/vnfcs/vnfc/vnfc-" + testName);
198 Introspector relationshipList = loader.introspectorFromName("relationship-list");
199 relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
201 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
202 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
203 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
204 gvnfObj.setValue("vnf-id", "vnf-" + testName);
206 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/vnf-" + testName));
208 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
209 assertTrue("Generic-vnf has uuid ", gvnf.property(AAIProperties.AAI_UUID).isPresent());
210 assertTrue("Edge has uuid ", gvnf.edges(Direction.BOTH).next().property(AAIProperties.AAI_UUID).isPresent());
215 public void createEdgeWithValidLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
217 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
219 engine.startTransaction();
221 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf", "aai-uri", "/network/generic-vnfs/generic-vnf/myvnf");
222 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
225 Introspector relData = loader.introspectorFromName("relationship-data");
226 relData.setValue("relationship-key", "vnfc.vnfc-name");
227 relData.setValue("relationship-value", "a-name");
228 Introspector relationship = loader.introspectorFromName("relationship");
229 relationship.setValue("related-to", "vnfc");
230 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
231 relationship.setValue("relationship-data",relData);
232 relationship.setValue("relationship-label", "over-uses");
234 assertTrue(localDbser.createEdge(relationship, gvnf));
235 assertTrue(engine.tx().traversal().V(gvnf).both("over-uses").hasNext());
236 assertTrue(engine.tx().traversal().V(vnfc).both("over-uses").hasNext());
241 public void createEdgeWithValidLabelWhenSameEdgeExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
243 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
244 engine.startTransaction();
246 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf", "aai-uri", "/network/generic-vnfs/generic-vnf/myvnf");
247 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
248 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "re-uses");
250 Introspector relData = loader.introspectorFromName("relationship-data");
251 relData.setValue("relationship-key", "vnfc.vnfc-name");
252 relData.setValue("relationship-value", "a-name");
253 Introspector relationship = loader.introspectorFromName("relationship");
254 relationship.setValue("related-to", "vnfc");
255 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
256 relationship.setValue("relationship-data",relData);
257 relationship.setValue("relationship-label", "re-uses");
259 assertTrue(localDbser.createEdge(relationship, gvnf));
260 assertTrue(engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
261 assertTrue(engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
262 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V(vnfc).both().count().next());
267 public void createEdgeWithValidLabelWhenDiffEdgeExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
269 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
270 engine.startTransaction();
272 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf", "aai-uri", "/network/generic-vnfs/generic-vnf/myvnf");
273 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
274 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "uses");
276 Introspector relData = loader.introspectorFromName("relationship-data");
277 relData.setValue("relationship-key", "vnfc.vnfc-name");
278 relData.setValue("relationship-value", "a-name");
279 Introspector relationship = loader.introspectorFromName("relationship");
280 relationship.setValue("related-to", "vnfc");
281 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
282 relationship.setValue("relationship-data",relData);
283 relationship.setValue("relationship-label", "uses");
284 localDbser.createEdge(relationship, gvnf);
286 relationship.setValue("relationship-label", "re-uses");
288 assertTrue(localDbser.createEdge(relationship, gvnf));
289 assertTrue(engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
290 assertTrue(engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
291 assertTrue(engine.tx().traversal().V(gvnf).both("uses").hasNext());
292 assertTrue(engine.tx().traversal().V(vnfc).both("uses").hasNext());
293 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(vnfc).both().count().next());
294 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(gvnf).both().count().next());
299 public void createEdgeWithNoLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
301 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
302 engine.startTransaction();
304 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf", "aai-uri", "/network/generic-vnfs/generic-vnf/myvnf");
305 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
307 Introspector relData = loader.introspectorFromName("relationship-data");
308 relData.setValue("relationship-key", "vnfc.vnfc-name");
309 relData.setValue("relationship-value", "a-name");
310 Introspector relationship = loader.introspectorFromName("relationship");
311 relationship.setValue("related-to", "vnfc");
312 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
313 relationship.setValue("relationship-data",relData);
314 localDbser.createEdge(relationship, gvnf);
316 assertTrue(localDbser.createEdge(relationship, gvnf));
317 assertTrue(engine.tx().traversal().V(gvnf).both("uses").hasNext());
318 assertTrue(engine.tx().traversal().V(vnfc).both("uses").hasNext());
319 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V(vnfc).both().count().next());
320 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V(gvnf).both().count().next());
326 public void deleteEdgeWithNoLabelWhenMultipleExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
328 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
329 engine.startTransaction();
331 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf", "aai-uri", "/network/generic-vnfs/generic-vnf/myvnf");
332 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
333 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "uses");
334 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "re-uses");
335 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "over-uses");
337 Introspector relData = loader.introspectorFromName("relationship-data");
338 relData.setValue("relationship-key", "vnfc.vnfc-name");
339 relData.setValue("relationship-value", "a-name");
340 Introspector relationship = loader.introspectorFromName("relationship");
341 relationship.setValue("related-to", "vnfc");
342 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
343 relationship.setValue("relationship-data",relData);
345 assertTrue(localDbser.deleteEdge(relationship, gvnf));
346 assertFalse("generic-vnf has no edge uses", engine.tx().traversal().V(gvnf).both("uses").hasNext());
347 assertFalse("vnfc has no edge uses", engine.tx().traversal().V(vnfc).both("uses").hasNext());
348 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
349 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
350 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V(gvnf).both("over-uses").hasNext());
351 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V(vnfc).both("over-uses").hasNext());
352 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(vnfc).both().count().next());
353 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(gvnf).both().count().next());
358 public void deleteEdgeWithValidLabelWhenMultipleExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
360 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
362 engine.startTransaction();
364 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf", "aai-uri", "/network/generic-vnfs/generic-vnf/myvnf");
365 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
366 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "uses");
367 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "re-uses");
368 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "over-uses");
370 Introspector relData = loader.introspectorFromName("relationship-data");
371 relData.setValue("relationship-key", "vnfc.vnfc-name");
372 relData.setValue("relationship-value", "a-name");
373 Introspector relationship = loader.introspectorFromName("relationship");
374 relationship.setValue("related-to", "vnfc");
375 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
376 relationship.setValue("relationship-data",relData);
377 relationship.setValue("relationship-label", "re-uses");
379 assertTrue(localDbser.deleteEdge(relationship, gvnf));
380 assertTrue("generic-vnf has edge uses", engine.tx().traversal().V(gvnf).both("uses").hasNext());
381 assertTrue("vnfc has edge uses", engine.tx().traversal().V(vnfc).both("uses").hasNext());
382 assertFalse("generic-vnf has no edge re-uses", engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
383 assertFalse("vnfc has no edge re-uses", engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
384 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V(gvnf).both("over-uses").hasNext());
385 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V(vnfc).both("over-uses").hasNext());
386 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(vnfc).both().count().next());
387 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(gvnf).both().count().next());
392 public void deleteEdgeWithValidInvalidLabelWhenMultipleExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
394 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
396 engine.startTransaction();
398 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf", "aai-uri", "/network/generic-vnfs/generic-vnf/myvnf");
399 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
400 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "uses");
401 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "re-uses");
402 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "over-uses");
404 Introspector relData = loader.introspectorFromName("relationship-data");
405 relData.setValue("relationship-key", "vnfc.vnfc-name");
406 relData.setValue("relationship-value", "a-name");
407 Introspector relationship = loader.introspectorFromName("relationship");
408 relationship.setValue("related-to", "vnfc");
409 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
410 relationship.setValue("relationship-data",relData);
411 relationship.setValue("relationship-label", "NA");
413 thrown.expect(AAIException.class);
414 thrown.expectMessage("No rule found");
415 thrown.expectMessage("node type: generic-vnf, node type: vnfc, label: NA, type: COUSIN");
416 localDbser.deleteEdge(relationship, gvnf);
420 public void serializeToDbWithLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
422 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
424 engine.startTransaction();
426 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
428 Introspector relationship = loader.introspectorFromName("relationship");
429 relationship.setValue("related-to", "vnfc");
430 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
431 relationship.setValue("relationship-label", "re-uses");
432 Introspector relationshipList = loader.introspectorFromName("relationship-list");
433 relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
435 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
436 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
437 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
438 gvnfObj.setValue("vnf-id", "myvnf");
440 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
442 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
444 assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
445 assertTrue("vertex with vnfc-name a-name exists", engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
446 assertFalse("generic-vnf has no edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
447 assertFalse("vnfc has no edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
448 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
449 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
450 assertFalse("generic-vnf has no edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
451 assertFalse("vnfc has no edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
452 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
453 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
458 public void serializeToDbWithoutLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
460 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
462 engine.startTransaction();
464 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
466 Introspector relationship = loader.introspectorFromName("relationship");
467 relationship.setValue("related-to", "vnfc");
468 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
470 Introspector relationshipList = loader.introspectorFromName("relationship-list");
471 relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
473 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
474 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
475 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
476 gvnfObj.setValue("vnf-id", "myvnf");
478 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
480 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
482 assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
483 assertTrue("vertex with vnfc-name a-name exists", engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
484 assertTrue("generic-vnf has edge uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
485 assertTrue("vnfc has edge uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
486 assertFalse("generic-vnf has no edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
487 assertFalse("vnfc has no edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
488 assertFalse("generic-vnf has no edge over-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
489 assertFalse("vnfc has no edge over-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
490 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
491 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
496 public void serializeToDbWithInvalidLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
498 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
500 engine.startTransaction();
502 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
504 Introspector relationship = loader.introspectorFromName("relationship");
505 relationship.setValue("related-to", "vnfc");
506 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
507 relationship.setValue("relationship-label", "NA");
508 Introspector relationshipList = loader.introspectorFromName("relationship-list");
509 relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
511 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
512 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
513 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
514 gvnfObj.setValue("vnf-id", "myvnf");
516 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
518 thrown.expect(AAIException.class);
519 thrown.expectMessage("No EdgeRule found for passed nodeTypes: generic-vnf, vnfc with label NA.");
520 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
525 public void serializeToDbWithLabelAndEdgeExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
527 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
529 engine.startTransaction();
530 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
532 Introspector relationship;
533 Introspector relationshipList;
534 List<Object> relList = new ArrayList<>();
536 // create generic-vnf
537 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
538 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
539 gvnfObj.setValue("vnf-id", "myvnf");
540 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
542 // create relationship to vnfc
543 relationship = loader.introspectorFromName("relationship");
544 relationship.setValue("related-to", "vnfc");
545 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
546 relList.add(relationship.getUnderlyingObject());
547 relationshipList = loader.introspectorFromName("relationship-list");
548 relationshipList.setValue("relationship", relList);
549 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
552 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
554 // add second relationship
555 relationship = loader.introspectorFromName("relationship");
556 relationship.setValue("related-to", "vnfc");
557 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
558 relationship.setValue("relationship-label", "re-uses");
559 relList.add(relationship.getUnderlyingObject());
560 relationshipList = loader.introspectorFromName("relationship-list");
561 relationshipList.setValue("relationship", relList);
562 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
564 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
566 assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
567 assertTrue("vertex with vnfc-name a-name exists", engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
568 assertTrue("generic-vnf has edge uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
569 assertTrue("vnfc has edge uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
570 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
571 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
572 assertFalse("generic-vnf has no edge over-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
573 assertFalse("vnfc has no edge over-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
574 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
575 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
580 public void serializeToDbWithLabelDroppingRelationshipTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
582 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
584 engine.startTransaction();
585 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
588 Introspector relationship;
589 Introspector relationshipList;
590 List<Object> relList = new ArrayList<>();
592 // create generic-vnf
593 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
594 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
595 gvnfObj.setValue("vnf-id", "myvnf");
596 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
598 // create relationship to vnfc
599 relationship = loader.introspectorFromName("relationship");
600 relationship.setValue("related-to", "vnfc");
601 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
602 relList.add(relationship.getUnderlyingObject());
603 // add second relationship
604 relationship = loader.introspectorFromName("relationship");
605 relationship.setValue("related-to", "vnfc");
606 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
607 relationship.setValue("relationship-label", "re-uses");
608 relList.add(relationship.getUnderlyingObject());
609 relationshipList = loader.introspectorFromName("relationship-list");
610 relationshipList.setValue("relationship", relList);
611 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
614 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
616 // drop second relationship
618 relationshipList = loader.introspectorFromName("relationship-list");
619 relationshipList.setValue("relationship", relList);
620 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
622 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
624 assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
625 assertTrue("vertex with vnfc-name a-name exists", engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
626 assertTrue("generic-vnf has edge uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
627 assertTrue("vnfc has edge uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
628 assertFalse("generic-vnf no longer has edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
629 assertFalse("vnfc no longer has edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
630 assertFalse("generic-vnf has no edge over-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
631 assertFalse("vnfc has no edge over-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
632 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
633 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
637 private DBSerializer getDBSerializerWithSpecificEdgeRules()
638 throws NoSuchFieldException, AAIException, IllegalAccessException {
641 DBSerializer localDbser = new DBSerializer(version, engine, introspectorFactoryType, "AAI-TEST");