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.config.ConfigConfiguration;
23 import org.onap.aai.setup.SchemaVersion;
24 import org.onap.aai.setup.SchemaVersions;
25 import org.onap.aai.util.AAIConstants;
26 import org.janusgraph.core.JanusGraphFactory;
27 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
28 import org.apache.tinkerpop.gremlin.structure.*;
30 import org.junit.rules.ExpectedException;
31 import org.junit.runner.RunWith;
32 import org.onap.aai.config.IntrospectionConfig;
33 import org.onap.aai.config.SpringContextAware;
34 import org.onap.aai.db.props.AAIProperties;
35 import org.onap.aai.dbmap.DBConnectionType;
36 import org.onap.aai.edges.EdgeIngestor;
37 import org.onap.aai.exceptions.AAIException;
38 import org.onap.aai.introspection.*;
39 import org.onap.aai.nodes.NodeIngestor;
40 import org.onap.aai.parsers.query.QueryParser;
41 import org.onap.aai.serialization.engines.QueryStyle;
42 import org.onap.aai.serialization.engines.JanusGraphDBEngine;
43 import org.onap.aai.serialization.engines.TransactionalGraphEngine;
44 import org.onap.aai.serialization.queryformats.QueryFormatTestHelper;
45 import org.onap.aai.setup.SchemaLocationsBean;
46 import org.springframework.beans.factory.annotation.Autowired;
47 import org.springframework.test.context.ContextConfiguration;
48 import org.springframework.test.context.TestPropertySource;
49 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
51 import java.io.UnsupportedEncodingException;
53 import java.net.URISyntaxException;
56 import static org.junit.Assert.*;
57 import static org.mockito.Mockito.spy;
58 import static org.mockito.Mockito.when;
60 //@RunWith(value = Parameterized.class) TODO replace this functionality
61 @RunWith(SpringJUnit4ClassRunner.class)
62 @ContextConfiguration(classes = {
63 ConfigConfiguration.class,
64 AAICoreFakeEdgesConfigTranslator.class,
68 SpringContextAware.class,
69 IntrospectionConfig.class
71 @TestPropertySource(properties = {
72 "schema.translator.list = config",
73 "schema.nodes.location=src/test/resources/onap/oxm",
74 "schema.edges.location=src/test/resources/onap/dbedgerules"
76 public class DbSerializer_needsFakeRulesTest {
78 //to use, set thrown.expect to whatever your test needs
79 //this line establishes default of expecting no exception to be thrown
81 public ExpectedException thrown = ExpectedException.none();
83 protected static Graph graph;
86 protected EdgeSerializer edgeSer;
88 protected EdgeIngestor ei;
90 protected SchemaVersions schemaVersions;
92 private SchemaVersion version;
93 private final ModelType introspectorFactoryType = ModelType.MOXY;
94 private final DBConnectionType type = DBConnectionType.REALTIME;
95 private Loader loader;
96 private TransactionalGraphEngine dbEngine;
97 private TransactionalGraphEngine engine; //for tests that aren't mocking the engine
98 private DBSerializer dbser;
99 TransactionalGraphEngine spy;
100 TransactionalGraphEngine.Admin adminSpy;
102 //@Parameterized.Parameter(value = 0)
103 public QueryStyle queryStyle = QueryStyle.TRAVERSAL;
105 /*@Parameterized.Parameters(name = "QueryStyle.{0}")
106 public static Collection<Object[]> data() {
107 return Arrays.asList(new Object[][]{
108 {QueryStyle.TRAVERSAL},
109 {QueryStyle.TRAVERSAL_URI}
114 public static void init() throws Exception {
115 graph = JanusGraphFactory.build().set("storage.backend", "inmemory").open();
116 System.setProperty("AJSC_HOME", ".");
117 System.setProperty("BUNDLECONFIG_DIR", "src/test/resources/bundleconfig-local");
118 QueryFormatTestHelper.setFinalStatic(AAIConstants.class.getField("AAI_HOME_ETC_OXM"), "src/test/resources/bundleconfig-local/etc/oxm/");
123 public void setup() throws Exception {
125 version = schemaVersions.getDefaultVersion();
126 loader = SpringContextAware.getBean(LoaderFactory.class).createLoaderForVersion(introspectorFactoryType, version);
127 dbEngine = new JanusGraphDBEngine(queryStyle, type, loader);
129 adminSpy = spy(dbEngine.asAdmin());
132 engine = new JanusGraphDBEngine(queryStyle, type, loader);
133 dbser = new DBSerializer(version, engine, introspectorFactoryType, "AAI-TEST");
137 public void tearDown() throws Exception {
142 public static void destroy() throws Exception {
146 public void subnetSetup() throws AAIException {
148 * This setus up the test graph, For future junits , add more vertices
152 Vertex l3interipv4addresslist_1 = graph.traversal().addV("aai-node-type", "l3-interface-ipv4-address-list",
153 "l3-interface-ipv4-address", "l3-interface-ipv4-address-1").next();
154 Vertex subnet_2 = graph.traversal().addV("aai-node-type", "subnet", "subnet-id", "subnet-id-2").next();
155 Vertex l3interipv6addresslist_3 = graph.traversal().addV("aai-node-type", "l3-interface-ipv6-address-list",
156 "l3-interface-ipv6-address", "l3-interface-ipv6-address-3").next();
157 Vertex subnet_4 = graph.traversal().addV("aai-node-type", "subnet", "subnet-id", "subnet-id-4").next();
158 Vertex subnet_5 = graph.traversal().addV("aai-node-type", "subnet", "subnet-id", "subnet-id-5").next();
159 Vertex l3network_6 = graph.traversal()
160 .addV("aai-node-type", "l3-network", "network-id", "network-id-6", "network-name", "network-name-6")
163 GraphTraversalSource g = graph.traversal();
164 edgeSer.addEdge(g, l3interipv4addresslist_1, subnet_2);
165 edgeSer.addEdge(g, l3interipv6addresslist_3, subnet_4);
166 edgeSer.addTreeEdge(g, subnet_5, l3network_6);
169 public String testDelete(Vertex v) throws AAIException {
171 GraphTraversalSource traversal = graph.traversal();
172 when(spy.asAdmin()).thenReturn(adminSpy);
173 when(adminSpy.getTraversalSource()).thenReturn(traversal);
174 when(adminSpy.getReadOnlyTraversalSource()).thenReturn(traversal);
176 String exceptionMessage = "";
177 DBSerializer serializer = new DBSerializer(version, spy, introspectorFactoryType, "AAI_TEST");
179 serializer.delete(v, "resourceVersion", false);
180 } catch (AAIException exception) {
181 exceptionMessage = exception.getMessage();
183 return exceptionMessage;
188 public void serializeToDbNewVertexAndEdgeAAIUUIDTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
189 String testName = new Object() {}.getClass().getEnclosingMethod().getName();
190 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
192 engine.startTransaction();
194 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","vnfc-" + testName, AAIProperties.AAI_URI, "/network/vnfcs/vnfc/vnfc-" + testName);
196 Introspector relationship = loader.introspectorFromName("relationship");
197 relationship.setValue("related-to", "vnfc");
198 relationship.setValue("related-link", "/network/vnfcs/vnfc/vnfc-" + testName);
200 Introspector relationshipList = loader.introspectorFromName("relationship-list");
201 relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
203 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
204 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
205 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
206 gvnfObj.setValue("vnf-id", "vnf-" + testName);
208 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/vnf-" + testName));
210 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
211 assertTrue("Generic-vnf has uuid ", gvnf.property(AAIProperties.AAI_UUID).isPresent());
212 assertTrue("Edge has uuid ", gvnf.edges(Direction.BOTH).next().property(AAIProperties.AAI_UUID).isPresent());
217 public void createEdgeWithValidLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
219 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
221 engine.startTransaction();
223 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf", "aai-uri", "/network/generic-vnfs/generic-vnf/myvnf");
224 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
227 Introspector relData = loader.introspectorFromName("relationship-data");
228 relData.setValue("relationship-key", "vnfc.vnfc-name");
229 relData.setValue("relationship-value", "a-name");
230 Introspector relationship = loader.introspectorFromName("relationship");
231 relationship.setValue("related-to", "vnfc");
232 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
233 relationship.setValue("relationship-data",relData);
234 relationship.setValue("relationship-label", "over-uses");
236 assertTrue(localDbser.createEdge(relationship, gvnf));
237 assertTrue(engine.tx().traversal().V(gvnf).both("over-uses").hasNext());
238 assertTrue(engine.tx().traversal().V(vnfc).both("over-uses").hasNext());
243 public void createEdgeWithValidLabelWhenSameEdgeExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
245 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
246 engine.startTransaction();
248 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf", "aai-uri", "/network/generic-vnfs/generic-vnf/myvnf");
249 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
250 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "re-uses");
252 Introspector relData = loader.introspectorFromName("relationship-data");
253 relData.setValue("relationship-key", "vnfc.vnfc-name");
254 relData.setValue("relationship-value", "a-name");
255 Introspector relationship = loader.introspectorFromName("relationship");
256 relationship.setValue("related-to", "vnfc");
257 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
258 relationship.setValue("relationship-data",relData);
259 relationship.setValue("relationship-label", "re-uses");
261 assertTrue(localDbser.createEdge(relationship, gvnf));
262 assertTrue(engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
263 assertTrue(engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
264 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V(vnfc).both().count().next());
269 public void createEdgeWithValidLabelWhenDiffEdgeExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
271 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
272 engine.startTransaction();
274 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf", "aai-uri", "/network/generic-vnfs/generic-vnf/myvnf");
275 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
276 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "uses");
278 Introspector relData = loader.introspectorFromName("relationship-data");
279 relData.setValue("relationship-key", "vnfc.vnfc-name");
280 relData.setValue("relationship-value", "a-name");
281 Introspector relationship = loader.introspectorFromName("relationship");
282 relationship.setValue("related-to", "vnfc");
283 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
284 relationship.setValue("relationship-data",relData);
285 relationship.setValue("relationship-label", "uses");
286 localDbser.createEdge(relationship, gvnf);
288 relationship.setValue("relationship-label", "re-uses");
290 assertTrue(localDbser.createEdge(relationship, gvnf));
291 assertTrue(engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
292 assertTrue(engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
293 assertTrue(engine.tx().traversal().V(gvnf).both("uses").hasNext());
294 assertTrue(engine.tx().traversal().V(vnfc).both("uses").hasNext());
295 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(vnfc).both().count().next());
296 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(gvnf).both().count().next());
301 public void createEdgeWithNoLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
303 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
304 engine.startTransaction();
306 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf", "aai-uri", "/network/generic-vnfs/generic-vnf/myvnf");
307 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
309 Introspector relData = loader.introspectorFromName("relationship-data");
310 relData.setValue("relationship-key", "vnfc.vnfc-name");
311 relData.setValue("relationship-value", "a-name");
312 Introspector relationship = loader.introspectorFromName("relationship");
313 relationship.setValue("related-to", "vnfc");
314 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
315 relationship.setValue("relationship-data",relData);
316 localDbser.createEdge(relationship, gvnf);
318 assertTrue(localDbser.createEdge(relationship, gvnf));
319 assertTrue(engine.tx().traversal().V(gvnf).both("uses").hasNext());
320 assertTrue(engine.tx().traversal().V(vnfc).both("uses").hasNext());
321 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V(vnfc).both().count().next());
322 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V(gvnf).both().count().next());
328 public void deleteEdgeWithNoLabelWhenMultipleExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
330 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
331 engine.startTransaction();
333 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf", "aai-uri", "/network/generic-vnfs/generic-vnf/myvnf");
334 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
335 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "uses");
336 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "re-uses");
337 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "over-uses");
339 Introspector relData = loader.introspectorFromName("relationship-data");
340 relData.setValue("relationship-key", "vnfc.vnfc-name");
341 relData.setValue("relationship-value", "a-name");
342 Introspector relationship = loader.introspectorFromName("relationship");
343 relationship.setValue("related-to", "vnfc");
344 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
345 relationship.setValue("relationship-data",relData);
347 assertTrue(localDbser.deleteEdge(relationship, gvnf));
348 assertFalse("generic-vnf has no edge uses", engine.tx().traversal().V(gvnf).both("uses").hasNext());
349 assertFalse("vnfc has no edge uses", engine.tx().traversal().V(vnfc).both("uses").hasNext());
350 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
351 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
352 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V(gvnf).both("over-uses").hasNext());
353 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V(vnfc).both("over-uses").hasNext());
354 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(vnfc).both().count().next());
355 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(gvnf).both().count().next());
360 public void deleteEdgeWithValidLabelWhenMultipleExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
362 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
364 engine.startTransaction();
366 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf", "aai-uri", "/network/generic-vnfs/generic-vnf/myvnf");
367 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
368 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "uses");
369 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "re-uses");
370 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "over-uses");
372 Introspector relData = loader.introspectorFromName("relationship-data");
373 relData.setValue("relationship-key", "vnfc.vnfc-name");
374 relData.setValue("relationship-value", "a-name");
375 Introspector relationship = loader.introspectorFromName("relationship");
376 relationship.setValue("related-to", "vnfc");
377 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
378 relationship.setValue("relationship-data",relData);
379 relationship.setValue("relationship-label", "re-uses");
381 assertTrue(localDbser.deleteEdge(relationship, gvnf));
382 assertTrue("generic-vnf has edge uses", engine.tx().traversal().V(gvnf).both("uses").hasNext());
383 assertTrue("vnfc has edge uses", engine.tx().traversal().V(vnfc).both("uses").hasNext());
384 assertFalse("generic-vnf has no edge re-uses", engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
385 assertFalse("vnfc has no edge re-uses", engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
386 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V(gvnf).both("over-uses").hasNext());
387 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V(vnfc).both("over-uses").hasNext());
388 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(vnfc).both().count().next());
389 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(gvnf).both().count().next());
394 public void deleteEdgeWithValidInvalidLabelWhenMultipleExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
396 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
398 engine.startTransaction();
400 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf", "aai-uri", "/network/generic-vnfs/generic-vnf/myvnf");
401 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
402 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "uses");
403 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "re-uses");
404 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "over-uses");
406 Introspector relData = loader.introspectorFromName("relationship-data");
407 relData.setValue("relationship-key", "vnfc.vnfc-name");
408 relData.setValue("relationship-value", "a-name");
409 Introspector relationship = loader.introspectorFromName("relationship");
410 relationship.setValue("related-to", "vnfc");
411 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
412 relationship.setValue("relationship-data",relData);
413 relationship.setValue("relationship-label", "NA");
415 thrown.expect(AAIException.class);
416 thrown.expectMessage("No rule found");
417 thrown.expectMessage("node type: generic-vnf, node type: vnfc, label: NA, type: COUSIN");
418 localDbser.deleteEdge(relationship, gvnf);
422 public void serializeToDbWithLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
424 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
426 engine.startTransaction();
428 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
430 Introspector relationship = loader.introspectorFromName("relationship");
431 relationship.setValue("related-to", "vnfc");
432 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
433 relationship.setValue("relationship-label", "re-uses");
434 Introspector relationshipList = loader.introspectorFromName("relationship-list");
435 relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
437 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
438 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
439 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
440 gvnfObj.setValue("vnf-id", "myvnf");
442 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
444 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
446 assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
447 assertTrue("vertex with vnfc-name a-name exists", engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
448 assertFalse("generic-vnf has no edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
449 assertFalse("vnfc has no edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
450 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
451 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
452 assertFalse("generic-vnf has no edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
453 assertFalse("vnfc has no edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
454 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
455 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
460 public void serializeToDbWithoutLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
462 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
464 engine.startTransaction();
466 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
468 Introspector relationship = loader.introspectorFromName("relationship");
469 relationship.setValue("related-to", "vnfc");
470 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
472 Introspector relationshipList = loader.introspectorFromName("relationship-list");
473 relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
475 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
476 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
477 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
478 gvnfObj.setValue("vnf-id", "myvnf");
480 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
482 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
484 assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
485 assertTrue("vertex with vnfc-name a-name exists", engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
486 assertTrue("generic-vnf has edge uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
487 assertTrue("vnfc has edge uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
488 assertFalse("generic-vnf has no edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
489 assertFalse("vnfc has no edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
490 assertFalse("generic-vnf has no edge over-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
491 assertFalse("vnfc has no edge over-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
492 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
493 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
498 public void serializeToDbWithInvalidLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
500 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
502 engine.startTransaction();
504 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
506 Introspector relationship = loader.introspectorFromName("relationship");
507 relationship.setValue("related-to", "vnfc");
508 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
509 relationship.setValue("relationship-label", "NA");
510 Introspector relationshipList = loader.introspectorFromName("relationship-list");
511 relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
513 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
514 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
515 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
516 gvnfObj.setValue("vnf-id", "myvnf");
518 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
520 thrown.expect(AAIException.class);
521 thrown.expectMessage("No EdgeRule found for passed nodeTypes: generic-vnf, vnfc with label NA.");
522 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
527 public void serializeToDbWithLabelAndEdgeExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
529 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
531 engine.startTransaction();
532 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
534 Introspector relationship;
535 Introspector relationshipList;
536 List<Object> relList = new ArrayList<>();
538 // create generic-vnf
539 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
540 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
541 gvnfObj.setValue("vnf-id", "myvnf");
542 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
544 // create relationship to vnfc
545 relationship = loader.introspectorFromName("relationship");
546 relationship.setValue("related-to", "vnfc");
547 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
548 relList.add(relationship.getUnderlyingObject());
549 relationshipList = loader.introspectorFromName("relationship-list");
550 relationshipList.setValue("relationship", relList);
551 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
554 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
556 // add second relationship
557 relationship = loader.introspectorFromName("relationship");
558 relationship.setValue("related-to", "vnfc");
559 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
560 relationship.setValue("relationship-label", "re-uses");
561 relList.add(relationship.getUnderlyingObject());
562 relationshipList = loader.introspectorFromName("relationship-list");
563 relationshipList.setValue("relationship", relList);
564 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
566 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
568 assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
569 assertTrue("vertex with vnfc-name a-name exists", engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
570 assertTrue("generic-vnf has edge uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
571 assertTrue("vnfc has edge uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
572 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
573 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
574 assertFalse("generic-vnf has no edge over-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
575 assertFalse("vnfc has no edge over-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
576 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
577 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
582 public void serializeToDbWithLabelDroppingRelationshipTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
584 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
586 engine.startTransaction();
587 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
590 Introspector relationship;
591 Introspector relationshipList;
592 List<Object> relList = new ArrayList<>();
594 // create generic-vnf
595 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
596 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
597 gvnfObj.setValue("vnf-id", "myvnf");
598 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
600 // create relationship to vnfc
601 relationship = loader.introspectorFromName("relationship");
602 relationship.setValue("related-to", "vnfc");
603 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
604 relList.add(relationship.getUnderlyingObject());
605 // add second relationship
606 relationship = loader.introspectorFromName("relationship");
607 relationship.setValue("related-to", "vnfc");
608 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
609 relationship.setValue("relationship-label", "re-uses");
610 relList.add(relationship.getUnderlyingObject());
611 relationshipList = loader.introspectorFromName("relationship-list");
612 relationshipList.setValue("relationship", relList);
613 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
616 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
618 // drop second relationship
620 relationshipList = loader.introspectorFromName("relationship-list");
621 relationshipList.setValue("relationship", relList);
622 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
624 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
626 assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
627 assertTrue("vertex with vnfc-name a-name exists", engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
628 assertTrue("generic-vnf has edge uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
629 assertTrue("vnfc has edge uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
630 assertFalse("generic-vnf no longer has edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
631 assertFalse("vnfc no longer has edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
632 assertFalse("generic-vnf has no edge over-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
633 assertFalse("vnfc has no edge over-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
634 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
635 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
639 private DBSerializer getDBSerializerWithSpecificEdgeRules()
640 throws NoSuchFieldException, AAIException, IllegalAccessException {
643 DBSerializer localDbser = new DBSerializer(version, engine, introspectorFactoryType, "AAI-TEST");