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=========================================================
21 package org.onap.aai.serialization.db;
23 import static org.junit.Assert.*;
24 import static org.mockito.Mockito.spy;
25 import static org.mockito.Mockito.when;
27 import java.io.UnsupportedEncodingException;
29 import java.net.URISyntaxException;
30 import java.util.ArrayList;
31 import java.util.Collections;
32 import java.util.List;
33 import java.util.UUID;
35 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
36 import org.apache.tinkerpop.gremlin.structure.Direction;
37 import org.apache.tinkerpop.gremlin.structure.Graph;
38 import org.apache.tinkerpop.gremlin.structure.Vertex;
39 import org.janusgraph.core.JanusGraphFactory;
41 import org.junit.rules.ExpectedException;
42 import org.junit.runner.RunWith;
43 import org.onap.aai.config.ConfigConfiguration;
44 import org.onap.aai.config.IntrospectionConfig;
45 import org.onap.aai.config.SpringContextAware;
46 import org.onap.aai.config.XmlFormatTransformerConfiguration;
47 import org.onap.aai.db.props.AAIProperties;
48 import org.onap.aai.edges.EdgeIngestor;
49 import org.onap.aai.exceptions.AAIException;
50 import org.onap.aai.introspection.Introspector;
51 import org.onap.aai.introspection.Loader;
52 import org.onap.aai.introspection.LoaderFactory;
53 import org.onap.aai.introspection.ModelType;
54 import org.onap.aai.nodes.NodeIngestor;
55 import org.onap.aai.parsers.query.QueryParser;
56 import org.onap.aai.serialization.engines.JanusGraphDBEngine;
57 import org.onap.aai.serialization.engines.QueryStyle;
58 import org.onap.aai.serialization.engines.TransactionalGraphEngine;
59 import org.onap.aai.serialization.queryformats.QueryFormatTestHelper;
60 import org.onap.aai.setup.SchemaVersion;
61 import org.onap.aai.setup.SchemaVersions;
62 import org.onap.aai.util.AAIConstants;
63 import org.springframework.beans.factory.annotation.Autowired;
64 import org.springframework.test.context.ContextConfiguration;
65 import org.springframework.test.context.TestPropertySource;
66 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
68 //@RunWith(value = Parameterized.class) TODO replace this functionality
69 @RunWith(SpringJUnit4ClassRunner.class)
70 @ContextConfiguration(
71 classes = {ConfigConfiguration.class, AAICoreFakeEdgesConfigTranslator.class, NodeIngestor.class,
72 EdgeIngestor.class, EdgeSerializer.class, SpringContextAware.class, IntrospectionConfig.class,
73 XmlFormatTransformerConfiguration.class})
75 properties = {"schema.translator.list = config", "schema.nodes.location=src/test/resources/onap/oxm",
76 "schema.edges.location=src/test/resources/onap/dbedgerules"})
77 public class DbSerializer_needsFakeRulesTest {
79 // to use, set thrown.expect to whatever your test needs
80 // this line establishes default of expecting no exception to be thrown
82 public ExpectedException thrown = ExpectedException.none();
84 protected static Graph graph;
87 protected EdgeSerializer edgeSer;
89 protected EdgeIngestor ei;
91 protected SchemaVersions schemaVersions;
93 private SchemaVersion version;
94 private final ModelType introspectorFactoryType = ModelType.MOXY;
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 public QueryStyle queryStyle = QueryStyle.TRAVERSAL;
105 public static void init() throws Exception {
106 graph = JanusGraphFactory.build().set("storage.backend", "inmemory").open();
107 System.setProperty("AJSC_HOME", ".");
108 System.setProperty("BUNDLECONFIG_DIR", "src/test/resources/bundleconfig-local");
109 QueryFormatTestHelper.setFinalStatic(AAIConstants.class.getField("AAI_HOME_ETC_OXM"),
110 "src/test/resources/bundleconfig-local/etc/oxm/");
115 public void setup() throws Exception {
116 version = schemaVersions.getDefaultVersion();
117 loader = SpringContextAware.getBean(LoaderFactory.class).createLoaderForVersion(introspectorFactoryType,
119 dbEngine = new JanusGraphDBEngine(queryStyle, loader);
121 adminSpy = spy(dbEngine.asAdmin());
123 engine = new JanusGraphDBEngine(queryStyle, loader);
124 dbser = new DBSerializer(version, engine, introspectorFactoryType, "AAI-TEST");
128 public void tearDown() throws Exception {
133 public static void destroy() throws Exception {
137 public void subnetSetup() throws AAIException {
139 * This setus up the test graph, For future junits , add more vertices
143 Vertex l3interipv4addresslist_1 = graph.addVertex("aai-node-type", "l3-interface-ipv4-address-list",
144 "l3-interface-ipv4-address", "l3-interface-ipv4-address-1");
145 Vertex subnet_2 = graph.addVertex("aai-node-type", "subnet", "subnet-id", "subnet-id-2");
146 Vertex l3interipv6addresslist_3 = graph.addVertex("aai-node-type", "l3-interface-ipv6-address-list",
147 "l3-interface-ipv6-address", "l3-interface-ipv6-address-3");
148 Vertex subnet_4 = graph.addVertex("aai-node-type", "subnet", "subnet-id", "subnet-id-4");
149 Vertex subnet_5 = graph.addVertex("aai-node-type", "subnet", "subnet-id", "subnet-id-5");
150 Vertex l3network_6 = graph.addVertex("aai-node-type", "l3-network", "network-id", "network-id-6",
151 "network-name", "network-name-6");
153 GraphTraversalSource g = graph.traversal();
154 edgeSer.addEdge(g, l3interipv4addresslist_1, subnet_2);
155 edgeSer.addEdge(g, l3interipv6addresslist_3, subnet_4);
156 edgeSer.addTreeEdge(g, subnet_5, l3network_6);
159 public String testDelete(Vertex v) throws AAIException {
161 GraphTraversalSource traversal = graph.traversal();
162 when(spy.asAdmin()).thenReturn(adminSpy);
163 when(adminSpy.getTraversalSource()).thenReturn(traversal);
164 when(adminSpy.getReadOnlyTraversalSource()).thenReturn(traversal);
166 String exceptionMessage = "";
167 DBSerializer serializer = new DBSerializer(version, spy, introspectorFactoryType, "AAI_TEST");
169 serializer.delete(v, "resourceVersion", false);
170 } catch (AAIException exception) {
171 exceptionMessage = exception.getMessage();
173 return exceptionMessage;
178 public void serializeToDbNewVertexAndEdgeAAIUUIDTest()
179 throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException,
180 IllegalArgumentException, IllegalAccessException, URISyntaxException {
181 String testName = new Object() {}.getClass().getEnclosingMethod().getName();
182 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
184 engine.startTransaction();
186 engine.tx().addVertex("aai-node-type", "vnfc", "vnfc-name", "vnfc-" + testName, AAIProperties.AAI_URI,
187 "/network/vnfcs/vnfc/vnfc-" + testName, AAIProperties.AAI_UUID, UUID.randomUUID().toString(),
188 AAIProperties.CREATED_TS, 123, AAIProperties.SOURCE_OF_TRUTH, "sot", AAIProperties.RESOURCE_VERSION,
189 "123", AAIProperties.LAST_MOD_SOURCE_OF_TRUTH, "lmsot", AAIProperties.LAST_MOD_TS, 333);
191 Introspector relationship = loader.introspectorFromName("relationship");
192 relationship.setValue("related-to", "vnfc");
193 relationship.setValue("related-link", "/network/vnfcs/vnfc/vnfc-" + testName);
195 Introspector relationshipList = loader.introspectorFromName("relationship-list");
196 relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
198 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
199 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
200 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
201 gvnfObj.setValue("vnf-id", "vnf-" + testName);
203 QueryParser uriQuery = dbEngine.getQueryBuilder()
204 .createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/vnf-" + testName));
206 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
207 assertTrue("Generic-vnf has uuid ", gvnf.property(AAIProperties.AAI_UUID).isPresent());
208 assertTrue("Edge has uuid ", gvnf.edges(Direction.BOTH).next().property(AAIProperties.AAI_UUID).isPresent());
213 public void createEdgeWithValidLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException,
214 SecurityException, IllegalArgumentException, IllegalAccessException {
216 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
218 engine.startTransaction();
220 Vertex gvnf = engine.tx().addVertex("aai-node-type", "generic-vnf", "vnf-id", "myvnf", "aai-uri",
221 "/network/generic-vnfs/generic-vnf/myvnf", "aai-uuid", "a", AAIProperties.CREATED_TS, 123,
222 AAIProperties.SOURCE_OF_TRUTH, "sot", AAIProperties.RESOURCE_VERSION, "123",
223 AAIProperties.LAST_MOD_SOURCE_OF_TRUTH, "lmsot", AAIProperties.LAST_MOD_TS, 333);
224 Vertex vnfc = engine.tx().addVertex("aai-node-type", "vnfc", "vnfc-name", "a-name", "aai-uri",
225 "/network/vnfcs/vnfc/a-name", "aai-uuid", "b", AAIProperties.CREATED_TS, 123,
226 AAIProperties.SOURCE_OF_TRUTH, "sot", AAIProperties.RESOURCE_VERSION, "123",
227 AAIProperties.LAST_MOD_SOURCE_OF_TRUTH, "lmsot", AAIProperties.LAST_MOD_TS, 333);
230 Introspector relData = loader.introspectorFromName("relationship-data");
231 relData.setValue("relationship-key", "vnfc.vnfc-name");
232 relData.setValue("relationship-value", "a-name");
233 Introspector relationship = loader.introspectorFromName("relationship");
234 relationship.setValue("related-to", "vnfc");
235 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
236 relationship.setValue("relationship-data", relData);
237 relationship.setValue("relationship-label", "over-uses");
239 assertNotNull(dbser.createEdge(relationship, gvnf));
240 assertTrue(engine.tx().traversal().V(gvnf).both("over-uses").hasNext());
241 assertTrue(engine.tx().traversal().V(vnfc).both("over-uses").hasNext());
246 public void createEdgeWithValidLabelWhenSameEdgeExistsTest() throws AAIException, UnsupportedEncodingException,
247 NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
249 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
250 engine.startTransaction();
252 Vertex gvnf = engine.tx().addVertex("aai-node-type", "generic-vnf", "vnf-id", "myvnf", "aai-uri",
253 "/network/generic-vnfs/generic-vnf/myvnf");
254 Vertex vnfc = engine.tx().addVertex("aai-node-type", "vnfc", "vnfc-name", "a-name", "aai-uri",
255 "/network/vnfcs/vnfc/a-name");
256 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "re-uses");
258 Introspector relData = loader.introspectorFromName("relationship-data");
259 relData.setValue("relationship-key", "vnfc.vnfc-name");
260 relData.setValue("relationship-value", "a-name");
261 Introspector relationship = loader.introspectorFromName("relationship");
262 relationship.setValue("related-to", "vnfc");
263 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
264 relationship.setValue("relationship-data", relData);
265 relationship.setValue("relationship-label", "re-uses");
267 assertNotNull(dbser.createEdge(relationship, gvnf));
268 assertTrue(engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
269 assertTrue(engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
270 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1),
271 engine.tx().traversal().V(vnfc).both().count().next());
276 public void createEdgeWithValidLabelWhenDiffEdgeExistsTest() throws AAIException, UnsupportedEncodingException,
277 NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
279 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
280 engine.startTransaction();
282 Vertex gvnf = engine.tx().addVertex("aai-node-type", "generic-vnf", "vnf-id", "myvnf", "aai-uri",
283 "/network/generic-vnfs/generic-vnf/myvnf", AAIProperties.AAI_UUID, UUID.randomUUID().toString(),
284 AAIProperties.CREATED_TS, 123, AAIProperties.SOURCE_OF_TRUTH, "sot", AAIProperties.RESOURCE_VERSION,
285 "123", AAIProperties.LAST_MOD_SOURCE_OF_TRUTH, "lmsot", AAIProperties.LAST_MOD_TS, 333);
286 Vertex vnfc = engine.tx().addVertex("aai-node-type", "vnfc", "vnfc-name", "a-name", "aai-uri",
287 "/network/vnfcs/vnfc/a-name", AAIProperties.AAI_UUID, UUID.randomUUID().toString(),
288 AAIProperties.CREATED_TS, 123, AAIProperties.SOURCE_OF_TRUTH, "sot", AAIProperties.RESOURCE_VERSION,
289 "123", AAIProperties.LAST_MOD_SOURCE_OF_TRUTH, "lmsot", AAIProperties.LAST_MOD_TS, 333);
290 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "uses");
292 Introspector relData = loader.introspectorFromName("relationship-data");
293 relData.setValue("relationship-key", "vnfc.vnfc-name");
294 relData.setValue("relationship-value", "a-name");
295 Introspector relationship = loader.introspectorFromName("relationship");
296 relationship.setValue("related-to", "vnfc");
297 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
298 relationship.setValue("relationship-data", relData);
299 relationship.setValue("relationship-label", "uses");
300 localDbser.createEdge(relationship, gvnf);
302 relationship.setValue("relationship-label", "re-uses");
304 assertNotNull(dbser.createEdge(relationship, gvnf));
305 assertTrue(engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
306 assertTrue(engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
307 assertTrue(engine.tx().traversal().V(gvnf).both("uses").hasNext());
308 assertTrue(engine.tx().traversal().V(vnfc).both("uses").hasNext());
309 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2),
310 engine.tx().traversal().V(vnfc).both().count().next());
311 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2),
312 engine.tx().traversal().V(gvnf).both().count().next());
317 public void createEdgeWithNoLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException,
318 SecurityException, IllegalArgumentException, IllegalAccessException {
320 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
321 engine.startTransaction();
323 Vertex gvnf = engine.tx().addVertex("aai-node-type", "generic-vnf", "vnf-id", "myvnf", "aai-uri",
324 "/network/generic-vnfs/generic-vnf/myvnf", AAIProperties.AAI_UUID, UUID.randomUUID().toString(),
325 AAIProperties.CREATED_TS, 123, AAIProperties.SOURCE_OF_TRUTH, "sot", AAIProperties.RESOURCE_VERSION,
326 "123", AAIProperties.LAST_MOD_SOURCE_OF_TRUTH, "lmsot", AAIProperties.LAST_MOD_TS, 333);
327 Vertex vnfc = engine.tx().addVertex("aai-node-type", "vnfc", "vnfc-name", "a-name", "aai-uri",
328 "/network/vnfcs/vnfc/a-name", AAIProperties.AAI_UUID, UUID.randomUUID().toString(),
329 AAIProperties.CREATED_TS, 123, AAIProperties.SOURCE_OF_TRUTH, "sot", AAIProperties.RESOURCE_VERSION,
330 "123", AAIProperties.LAST_MOD_SOURCE_OF_TRUTH, "lmsot", AAIProperties.LAST_MOD_TS, 333);
332 Introspector relData = loader.introspectorFromName("relationship-data");
333 relData.setValue("relationship-key", "vnfc.vnfc-name");
334 relData.setValue("relationship-value", "a-name");
335 Introspector relationship = loader.introspectorFromName("relationship");
336 relationship.setValue("related-to", "vnfc");
337 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
338 relationship.setValue("relationship-data", relData);
339 localDbser.createEdge(relationship, gvnf);
341 assertNotNull(dbser.createEdge(relationship, gvnf));
342 assertTrue(engine.tx().traversal().V(gvnf).both("uses").hasNext());
343 assertTrue(engine.tx().traversal().V(vnfc).both("uses").hasNext());
344 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1),
345 engine.tx().traversal().V(vnfc).both().count().next());
346 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1),
347 engine.tx().traversal().V(gvnf).both().count().next());
352 public void deleteEdgeWithNoLabelWhenMultipleExistsTest() throws AAIException, UnsupportedEncodingException,
353 NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
355 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
356 engine.startTransaction();
358 Vertex gvnf = engine.tx().addVertex("aai-node-type", "generic-vnf", "vnf-id", "myvnf", "aai-uri",
359 "/network/generic-vnfs/generic-vnf/myvnf", AAIProperties.AAI_UUID, UUID.randomUUID().toString(),
360 AAIProperties.CREATED_TS, 123, AAIProperties.SOURCE_OF_TRUTH, "sot", AAIProperties.RESOURCE_VERSION,
361 "123", AAIProperties.LAST_MOD_SOURCE_OF_TRUTH, "lmsot", AAIProperties.LAST_MOD_TS, 333);
362 Vertex vnfc = engine.tx().addVertex("aai-node-type", "vnfc", "vnfc-name", "a-name", "aai-uri",
363 "/network/vnfcs/vnfc/a-name", AAIProperties.AAI_UUID, UUID.randomUUID().toString(),
364 AAIProperties.CREATED_TS, 123, AAIProperties.SOURCE_OF_TRUTH, "sot", AAIProperties.RESOURCE_VERSION,
365 "123", AAIProperties.LAST_MOD_SOURCE_OF_TRUTH, "lmsot", AAIProperties.LAST_MOD_TS, 333);
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);
378 assertTrue(localDbser.deleteEdge(relationship, gvnf).isPresent());
379 assertFalse("generic-vnf has no edge uses", engine.tx().traversal().V(gvnf).both("uses").hasNext());
380 assertFalse("vnfc has no edge uses", engine.tx().traversal().V(vnfc).both("uses").hasNext());
381 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
382 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
383 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V(gvnf).both("over-uses").hasNext());
384 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V(vnfc).both("over-uses").hasNext());
385 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2),
386 engine.tx().traversal().V(vnfc).both().count().next());
387 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2),
388 engine.tx().traversal().V(gvnf).both().count().next());
393 public void deleteEdgeWithValidLabelWhenMultipleExistsTest() throws AAIException, UnsupportedEncodingException,
394 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",
401 "/network/generic-vnfs/generic-vnf/myvnf", AAIProperties.AAI_UUID, UUID.randomUUID().toString(),
402 AAIProperties.CREATED_TS, 123, AAIProperties.SOURCE_OF_TRUTH, "sot", AAIProperties.RESOURCE_VERSION,
403 "123", AAIProperties.LAST_MOD_SOURCE_OF_TRUTH, "lmsot", AAIProperties.LAST_MOD_TS, 333);
404 Vertex vnfc = engine.tx().addVertex("aai-node-type", "vnfc", "vnfc-name", "a-name", "aai-uri",
405 "/network/vnfcs/vnfc/a-name", AAIProperties.AAI_UUID, UUID.randomUUID().toString(),
406 AAIProperties.CREATED_TS, 123, AAIProperties.SOURCE_OF_TRUTH, "sot", AAIProperties.RESOURCE_VERSION,
407 "123", AAIProperties.LAST_MOD_SOURCE_OF_TRUTH, "lmsot", AAIProperties.LAST_MOD_TS, 333);
408 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "uses");
409 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "re-uses");
410 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "over-uses");
412 Introspector relData = loader.introspectorFromName("relationship-data");
413 relData.setValue("relationship-key", "vnfc.vnfc-name");
414 relData.setValue("relationship-value", "a-name");
415 Introspector relationship = loader.introspectorFromName("relationship");
416 relationship.setValue("related-to", "vnfc");
417 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
418 relationship.setValue("relationship-data", relData);
419 relationship.setValue("relationship-label", "re-uses");
421 assertTrue(localDbser.deleteEdge(relationship, gvnf).isPresent());
422 assertTrue("generic-vnf has edge uses", engine.tx().traversal().V(gvnf).both("uses").hasNext());
423 assertTrue("vnfc has edge uses", engine.tx().traversal().V(vnfc).both("uses").hasNext());
424 assertFalse("generic-vnf has no edge re-uses", engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
425 assertFalse("vnfc has no edge re-uses", engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
426 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V(gvnf).both("over-uses").hasNext());
427 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V(vnfc).both("over-uses").hasNext());
428 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2),
429 engine.tx().traversal().V(vnfc).both().count().next());
430 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2),
431 engine.tx().traversal().V(gvnf).both().count().next());
436 public void deleteEdgeWithValidInvalidLabelWhenMultipleExistsTest()
437 throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException,
438 IllegalArgumentException, IllegalAccessException {
440 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
442 engine.startTransaction();
444 Vertex gvnf = engine.tx().addVertex("aai-node-type", "generic-vnf", "vnf-id", "myvnf", "aai-uri",
445 "/network/generic-vnfs/generic-vnf/myvnf");
446 Vertex vnfc = engine.tx().addVertex("aai-node-type", "vnfc", "vnfc-name", "a-name", "aai-uri",
447 "/network/vnfcs/vnfc/a-name");
448 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "uses");
449 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "re-uses");
450 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "over-uses");
452 Introspector relData = loader.introspectorFromName("relationship-data");
453 relData.setValue("relationship-key", "vnfc.vnfc-name");
454 relData.setValue("relationship-value", "a-name");
455 Introspector relationship = loader.introspectorFromName("relationship");
456 relationship.setValue("related-to", "vnfc");
457 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
458 relationship.setValue("relationship-data", relData);
459 relationship.setValue("relationship-label", "NA");
461 thrown.expect(AAIException.class);
462 thrown.expectMessage("No rule found");
463 thrown.expectMessage("node type: generic-vnf, node type: vnfc, label: NA, type: COUSIN");
464 localDbser.deleteEdge(relationship, gvnf);
468 public void serializeToDbWithLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException,
469 SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
471 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
473 engine.startTransaction();
475 engine.tx().addVertex("aai-node-type", "vnfc", "vnfc-name", "a-name", "aai-uri", "/network/vnfcs/vnfc/a-name",
476 "aai-uuid", "b", AAIProperties.CREATED_TS, 123, AAIProperties.SOURCE_OF_TRUTH, "sot",
477 AAIProperties.RESOURCE_VERSION, "123", AAIProperties.LAST_MOD_SOURCE_OF_TRUTH, "lmsot",
478 AAIProperties.LAST_MOD_TS, 333);
480 Introspector relationship = loader.introspectorFromName("relationship");
481 relationship.setValue("related-to", "vnfc");
482 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
483 relationship.setValue("relationship-label", "re-uses");
484 Introspector relationshipList = loader.introspectorFromName("relationship-list");
485 relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
487 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
488 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
489 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
490 gvnfObj.setValue("vnf-id", "myvnf");
492 QueryParser uriQuery =
493 dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
495 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
497 assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
498 assertTrue("vertex with vnfc-name a-name exists",
499 engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
500 assertFalse("generic-vnf has no edge re-uses",
501 engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
502 assertFalse("vnfc has no edge re-uses",
503 engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
504 assertTrue("generic-vnf has edge re-uses",
505 engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
506 assertTrue("vnfc has edge re-uses",
507 engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
508 assertFalse("generic-vnf has no edge re-uses",
509 engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
510 assertFalse("vnfc has no edge re-uses",
511 engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
512 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1),
513 engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
514 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1),
515 engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
520 public void serializeToDbWithoutLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException,
521 SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
523 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
525 engine.startTransaction();
527 engine.tx().addVertex("aai-node-type", "vnfc", "vnfc-name", "a-name", "aai-uri", "/network/vnfcs/vnfc/a-name",
528 AAIProperties.AAI_UUID, UUID.randomUUID().toString(), AAIProperties.CREATED_TS, 123,
529 AAIProperties.SOURCE_OF_TRUTH, "sot", AAIProperties.RESOURCE_VERSION, "123",
530 AAIProperties.LAST_MOD_SOURCE_OF_TRUTH, "lmsot", AAIProperties.LAST_MOD_TS, 333);
532 Introspector relationship = loader.introspectorFromName("relationship");
533 relationship.setValue("related-to", "vnfc");
534 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
536 Introspector relationshipList = loader.introspectorFromName("relationship-list");
537 relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
539 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
540 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
541 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
542 gvnfObj.setValue("vnf-id", "myvnf");
544 QueryParser uriQuery =
545 dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
547 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
549 assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
550 assertTrue("vertex with vnfc-name a-name exists",
551 engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
552 assertTrue("generic-vnf has edge uses",
553 engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
554 assertTrue("vnfc has edge uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
555 assertFalse("generic-vnf has no edge re-uses",
556 engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
557 assertFalse("vnfc has no edge re-uses",
558 engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
559 assertFalse("generic-vnf has no edge over-uses",
560 engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
561 assertFalse("vnfc has no edge over-uses",
562 engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
563 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1),
564 engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
565 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1),
566 engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
571 public void serializeToDbWithInvalidLabelTest()
572 throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException,
573 IllegalArgumentException, IllegalAccessException, URISyntaxException {
575 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
577 engine.startTransaction();
579 engine.tx().addVertex("aai-node-type", "vnfc", "vnfc-name", "a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
581 Introspector relationship = loader.introspectorFromName("relationship");
582 relationship.setValue("related-to", "vnfc");
583 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
584 relationship.setValue("relationship-label", "NA");
585 Introspector relationshipList = loader.introspectorFromName("relationship-list");
586 relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
588 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
589 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
590 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
591 gvnfObj.setValue("vnf-id", "myvnf");
593 QueryParser uriQuery =
594 dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
596 thrown.expect(AAIException.class);
597 thrown.expectMessage("No EdgeRule found for passed nodeTypes: generic-vnf, vnfc with label NA.");
598 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
603 public void serializeToDbWithLabelAndEdgeExistsTest()
604 throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException,
605 IllegalArgumentException, IllegalAccessException, URISyntaxException {
607 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
609 engine.startTransaction();
610 engine.tx().addVertex("aai-node-type", "vnfc", "vnfc-name", "a-name", "aai-uri", "/network/vnfcs/vnfc/a-name",
611 AAIProperties.AAI_UUID, UUID.randomUUID().toString(), AAIProperties.CREATED_TS, 123,
612 AAIProperties.SOURCE_OF_TRUTH, "sot", AAIProperties.RESOURCE_VERSION, "123",
613 AAIProperties.LAST_MOD_SOURCE_OF_TRUTH, "lmsot", AAIProperties.LAST_MOD_TS, 333);
615 Introspector relationship;
616 Introspector relationshipList;
617 List<Object> relList = new ArrayList<>();
619 // create generic-vnf
620 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
621 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
622 gvnfObj.setValue("vnf-id", "myvnf");
623 QueryParser uriQuery =
624 dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
626 // create relationship to vnfc
627 relationship = loader.introspectorFromName("relationship");
628 relationship.setValue("related-to", "vnfc");
629 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
630 relList.add(relationship.getUnderlyingObject());
631 relationshipList = loader.introspectorFromName("relationship-list");
632 relationshipList.setValue("relationship", relList);
633 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
636 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
638 // add second relationship
639 relationship = loader.introspectorFromName("relationship");
640 relationship.setValue("related-to", "vnfc");
641 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
642 relationship.setValue("relationship-label", "re-uses");
643 relList.add(relationship.getUnderlyingObject());
644 relationshipList = loader.introspectorFromName("relationship-list");
645 relationshipList.setValue("relationship", relList);
646 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
648 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
650 assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
651 assertTrue("vertex with vnfc-name a-name exists",
652 engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
653 assertTrue("generic-vnf has edge uses",
654 engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
655 assertTrue("vnfc has edge uses",
656 engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
657 assertTrue("generic-vnf has edge re-uses",
658 engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
659 assertTrue("vnfc has edge re-uses",
660 engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
661 assertFalse("generic-vnf has no edge over-uses",
662 engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
663 assertFalse("vnfc has no edge over-uses",
664 engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
665 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2),
666 engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
667 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2),
668 engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
673 public void serializeToDbWithLabelDroppingRelationshipTest()
674 throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException,
675 IllegalArgumentException, IllegalAccessException, URISyntaxException {
677 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
679 engine.startTransaction();
680 engine.tx().addVertex("aai-node-type", "vnfc", "vnfc-name", "a-name", "aai-uri", "/network/vnfcs/vnfc/a-name",
681 AAIProperties.AAI_UUID, UUID.randomUUID().toString(), AAIProperties.CREATED_TS, 123,
682 AAIProperties.SOURCE_OF_TRUTH, "sot", AAIProperties.RESOURCE_VERSION, "123",
683 AAIProperties.LAST_MOD_SOURCE_OF_TRUTH, "lmsot", AAIProperties.LAST_MOD_TS, 333);
685 Introspector relationship;
686 Introspector relationshipList;
687 List<Object> relList = new ArrayList<>();
689 // create generic-vnf
690 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
691 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
692 gvnfObj.setValue("vnf-id", "myvnf");
693 QueryParser uriQuery =
694 dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
696 // create relationship to vnfc
697 relationship = loader.introspectorFromName("relationship");
698 relationship.setValue("related-to", "vnfc");
699 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
700 relList.add(relationship.getUnderlyingObject());
701 // add second relationship
702 relationship = loader.introspectorFromName("relationship");
703 relationship.setValue("related-to", "vnfc");
704 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
705 relationship.setValue("relationship-label", "re-uses");
706 relList.add(relationship.getUnderlyingObject());
707 relationshipList = loader.introspectorFromName("relationship-list");
708 relationshipList.setValue("relationship", relList);
709 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
712 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
714 // drop second relationship
716 relationshipList = loader.introspectorFromName("relationship-list");
717 relationshipList.setValue("relationship", relList);
718 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
720 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
722 assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
723 assertTrue("vertex with vnfc-name a-name exists",
724 engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
725 assertTrue("generic-vnf has edge uses",
726 engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
727 assertTrue("vnfc has edge uses",
728 engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
729 assertFalse("generic-vnf no longer has edge re-uses",
730 engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
731 assertFalse("vnfc no longer has edge re-uses",
732 engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
733 assertFalse("generic-vnf has no edge over-uses",
734 engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
735 assertFalse("vnfc has no edge over-uses",
736 engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
737 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1),
738 engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
739 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1),
740 engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
744 private DBSerializer getDBSerializerWithSpecificEdgeRules() throws AAIException {
746 return new DBSerializer(version, engine, introspectorFactoryType, "AAI-TEST");