aai-core/src/test/java/org/onap/aai/serialization/db/DbSerializer_needsFakeRulesTest.java

   1 /**
   2  * ============LICENSE_START=======================================================
   3  * org.onap.aai
   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
  10  *
  11  *    http://www.apache.org/licenses/LICENSE-2.0
  12  *
  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=========================================================
  19  */
  20
  21 package org.onap.aai.serialization.db;
  22
  23 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
  24 import org.apache.tinkerpop.gremlin.structure.Direction;
  25 import org.apache.tinkerpop.gremlin.structure.Graph;
  26 import org.apache.tinkerpop.gremlin.structure.Vertex;
  27 import org.janusgraph.core.JanusGraphFactory;
  28 import org.junit.*;
  29 import org.junit.rules.ExpectedException;
  30 import org.junit.runner.RunWith;
  31 import org.onap.aai.config.ConfigConfiguration;
  32 import org.onap.aai.config.IntrospectionConfig;
  33 import org.onap.aai.config.SpringContextAware;
  34 import org.onap.aai.config.XmlFormatTransformerConfiguration;
  35 import org.onap.aai.db.props.AAIProperties;
  36 import org.onap.aai.edges.EdgeIngestor;
  37 import org.onap.aai.exceptions.AAIException;
  38 import org.onap.aai.introspection.Introspector;
  39 import org.onap.aai.introspection.Loader;
  40 import org.onap.aai.introspection.LoaderFactory;
  41 import org.onap.aai.introspection.ModelType;
  42 import org.onap.aai.nodes.NodeIngestor;
  43 import org.onap.aai.parsers.query.QueryParser;
  44 import org.onap.aai.serialization.engines.JanusGraphDBEngine;
  45 import org.onap.aai.serialization.engines.QueryStyle;
  46 import org.onap.aai.serialization.engines.TransactionalGraphEngine;
  47 import org.onap.aai.serialization.queryformats.QueryFormatTestHelper;
  48 import org.onap.aai.setup.SchemaVersion;
  49 import org.onap.aai.setup.SchemaVersions;
  50 import org.onap.aai.util.AAIConstants;
  51 import org.springframework.beans.factory.annotation.Autowired;
  52 import org.springframework.test.context.ContextConfiguration;
  53 import org.springframework.test.context.TestPropertySource;
  54 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  55
  56 import java.io.UnsupportedEncodingException;
  57 import java.net.URI;
  58 import java.net.URISyntaxException;
  59 import java.util.ArrayList;
  60 import java.util.Collections;
  61 import java.util.List;
  62 import java.util.UUID;
  63
  64 import static org.junit.Assert.*;
  65 import static org.mockito.Mockito.spy;
  66 import static org.mockito.Mockito.when;
  67
  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, XmlFormatTransformerConfiguration.class})
  73 @TestPropertySource(
  74         properties = {"schema.translator.list = config", "schema.nodes.location=src/test/resources/onap/oxm",
  75                 "schema.edges.location=src/test/resources/onap/dbedgerules"})
  76 public class DbSerializer_needsFakeRulesTest {
  77
  78     // to use, set thrown.expect to whatever your test needs
  79     // this line establishes default of expecting no exception to be thrown
  80     @Rule
  81     public ExpectedException thrown = ExpectedException.none();
  82
  83     protected static Graph graph;
  84
  85     @Autowired
  86     protected EdgeSerializer edgeSer;
  87     @Autowired
  88     protected EdgeIngestor ei;
  89     @Autowired
  90     protected SchemaVersions schemaVersions;
  91
  92     private SchemaVersion version;
  93     private final ModelType introspectorFactoryType = ModelType.MOXY;
  94     private Loader loader;
  95     private TransactionalGraphEngine dbEngine;
  96     private TransactionalGraphEngine engine; // for tests that aren't mocking the engine
  97     private DBSerializer dbser;
  98     TransactionalGraphEngine spy;
  99     TransactionalGraphEngine.Admin adminSpy;
 100
 101     public QueryStyle queryStyle = QueryStyle.TRAVERSAL;
 102
 103     @BeforeClass
 104     public static void init() throws Exception {
 105         graph = JanusGraphFactory.build().set("storage.backend", "inmemory").open();
 106         System.setProperty("AJSC_HOME", ".");
 107         System.setProperty("BUNDLECONFIG_DIR", "src/test/resources/bundleconfig-local");
 108         QueryFormatTestHelper.setFinalStatic(AAIConstants.class.getField("AAI_HOME_ETC_OXM"),
 109                 "src/test/resources/bundleconfig-local/etc/oxm/");
 110
 111     }
 112
 113     @Before
 114     public void setup() throws Exception {
 115         version = schemaVersions.getDefaultVersion();
 116         loader = SpringContextAware.getBean(LoaderFactory.class).createLoaderForVersion(introspectorFactoryType,
 117                 version);
 118         dbEngine = new JanusGraphDBEngine(queryStyle, loader);
 119         spy = spy(dbEngine);
 120         adminSpy = spy(dbEngine.asAdmin());
 121
 122         engine = new JanusGraphDBEngine(queryStyle, loader);
 123         dbser = new DBSerializer(version, engine, introspectorFactoryType, "AAI-TEST");
 124     }
 125
 126     @After
 127     public void tearDown() throws Exception {
 128         engine.rollback();
 129     }
 130
 131     @AfterClass
 132     public static void destroy() throws Exception {
 133         graph.close();
 134     }
 135
 136     public void subnetSetup() throws AAIException {
 137         /*
 138          * This setus up the test graph, For future junits , add more vertices
 139          * and edges
 140          */
 141
 142         Vertex l3interipv4addresslist_1 = graph.addVertex("aai-node-type", "l3-interface-ipv4-address-list",
 143                 "l3-interface-ipv4-address", "l3-interface-ipv4-address-1");
 144         Vertex subnet_2 = graph.addVertex("aai-node-type", "subnet", "subnet-id", "subnet-id-2");
 145         Vertex l3interipv6addresslist_3 = graph.addVertex("aai-node-type", "l3-interface-ipv6-address-list",
 146                 "l3-interface-ipv6-address", "l3-interface-ipv6-address-3");
 147         Vertex subnet_4 = graph.addVertex("aai-node-type", "subnet", "subnet-id", "subnet-id-4");
 148         Vertex subnet_5 = graph.addVertex("aai-node-type", "subnet", "subnet-id", "subnet-id-5");
 149         Vertex l3network_6 = graph.addVertex("aai-node-type", "l3-network", "network-id", "network-id-6", "network-name", "network-name-6");
 150
 151         GraphTraversalSource g = graph.traversal();
 152         edgeSer.addEdge(g, l3interipv4addresslist_1, subnet_2);
 153         edgeSer.addEdge(g, l3interipv6addresslist_3, subnet_4);
 154         edgeSer.addTreeEdge(g, subnet_5, l3network_6);
 155     }
 156
 157     public String testDelete(Vertex v) throws AAIException {
 158
 159         GraphTraversalSource traversal = graph.traversal();
 160         when(spy.asAdmin()).thenReturn(adminSpy);
 161         when(adminSpy.getTraversalSource()).thenReturn(traversal);
 162         when(adminSpy.getReadOnlyTraversalSource()).thenReturn(traversal);
 163
 164         String exceptionMessage = "";
 165         DBSerializer serializer = new DBSerializer(version, spy, introspectorFactoryType, "AAI_TEST");
 166         try {
 167             serializer.delete(v, "resourceVersion", false);
 168         } catch (AAIException exception) {
 169             exceptionMessage = exception.getMessage();
 170         }
 171         return exceptionMessage;
 172
 173     }
 174
 175     @Test
 176     public void serializeToDbNewVertexAndEdgeAAIUUIDTest()
 177             throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException,
 178             IllegalArgumentException, IllegalAccessException, URISyntaxException {
 179         String testName = new Object() {}.getClass().getEnclosingMethod().getName();
 180         DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 181
 182         engine.startTransaction();
 183
 184         engine.tx().addVertex("aai-node-type", "vnfc", "vnfc-name", "vnfc-" + testName, AAIProperties.AAI_URI,
 185                 "/network/vnfcs/vnfc/vnfc-" + testName,
 186             AAIProperties.AAI_UUID, UUID.randomUUID().toString(),
 187             AAIProperties.CREATED_TS, 123,
 188             AAIProperties.SOURCE_OF_TRUTH, "sot",
 189             AAIProperties.RESOURCE_VERSION, "123",
 190             AAIProperties.LAST_MOD_SOURCE_OF_TRUTH, "lmsot",
 191             AAIProperties.LAST_MOD_TS, 333);
 192
 193         Introspector relationship = loader.introspectorFromName("relationship");
 194         relationship.setValue("related-to", "vnfc");
 195         relationship.setValue("related-link", "/network/vnfcs/vnfc/vnfc-" + testName);
 196
 197         Introspector relationshipList = loader.introspectorFromName("relationship-list");
 198         relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
 199
 200         Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
 201         Vertex gvnf = localDbser.createNewVertex(gvnfObj);
 202         gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
 203         gvnfObj.setValue("vnf-id", "vnf-" + testName);
 204
 205         QueryParser uriQuery = dbEngine.getQueryBuilder()
 206                 .createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/vnf-" + testName));
 207
 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());
 211
 212     }
 213
 214     @Test
 215     public void createEdgeWithValidLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException,
 216             SecurityException, IllegalArgumentException, IllegalAccessException {
 217
 218         DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 219
 220         engine.startTransaction();
 221
 222         Vertex gvnf = engine.tx().addVertex("aai-node-type", "generic-vnf", "vnf-id", "myvnf", "aai-uri",
 223                 "/network/generic-vnfs/generic-vnf/myvnf", "aai-uuid", "a",
 224             AAIProperties.CREATED_TS, 123,
 225             AAIProperties.SOURCE_OF_TRUTH, "sot",
 226             AAIProperties.RESOURCE_VERSION, "123",
 227             AAIProperties.LAST_MOD_SOURCE_OF_TRUTH, "lmsot",
 228             AAIProperties.LAST_MOD_TS, 333);
 229         Vertex vnfc = engine.tx().addVertex("aai-node-type", "vnfc", "vnfc-name", "a-name", "aai-uri",
 230                 "/network/vnfcs/vnfc/a-name", "aai-uuid", "b",
 231             AAIProperties.CREATED_TS, 123,
 232             AAIProperties.SOURCE_OF_TRUTH, "sot",
 233             AAIProperties.RESOURCE_VERSION, "123",
 234             AAIProperties.LAST_MOD_SOURCE_OF_TRUTH, "lmsot",
 235             AAIProperties.LAST_MOD_TS, 333);
 236
 237         // sunny day case
 238         Introspector relData = loader.introspectorFromName("relationship-data");
 239         relData.setValue("relationship-key", "vnfc.vnfc-name");
 240         relData.setValue("relationship-value", "a-name");
 241         Introspector relationship = loader.introspectorFromName("relationship");
 242         relationship.setValue("related-to", "vnfc");
 243         relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 244         relationship.setValue("relationship-data", relData);
 245         relationship.setValue("relationship-label", "over-uses");
 246
 247         assertNotNull(dbser.createEdge(relationship, gvnf));
 248         assertTrue(engine.tx().traversal().V(gvnf).both("over-uses").hasNext());
 249         assertTrue(engine.tx().traversal().V(vnfc).both("over-uses").hasNext());
 250
 251     }
 252
 253     @Test
 254     public void createEdgeWithValidLabelWhenSameEdgeExistsTest() throws AAIException, UnsupportedEncodingException,
 255             NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
 256
 257         DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 258         engine.startTransaction();
 259
 260         Vertex gvnf = engine.tx().addVertex("aai-node-type", "generic-vnf", "vnf-id", "myvnf", "aai-uri",
 261                 "/network/generic-vnfs/generic-vnf/myvnf");
 262         Vertex vnfc = engine.tx().addVertex("aai-node-type", "vnfc", "vnfc-name", "a-name", "aai-uri",
 263                 "/network/vnfcs/vnfc/a-name");
 264         edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "re-uses");
 265
 266         Introspector relData = loader.introspectorFromName("relationship-data");
 267         relData.setValue("relationship-key", "vnfc.vnfc-name");
 268         relData.setValue("relationship-value", "a-name");
 269         Introspector relationship = loader.introspectorFromName("relationship");
 270         relationship.setValue("related-to", "vnfc");
 271         relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 272         relationship.setValue("relationship-data", relData);
 273         relationship.setValue("relationship-label", "re-uses");
 274
 275         assertNotNull(dbser.createEdge(relationship, gvnf));
 276         assertTrue(engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
 277         assertTrue(engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
 278         assertEquals("Number of edges between vertexes is 1", Long.valueOf(1),
 279                 engine.tx().traversal().V(vnfc).both().count().next());
 280
 281     }
 282
 283     @Test
 284     public void createEdgeWithValidLabelWhenDiffEdgeExistsTest() throws AAIException, UnsupportedEncodingException,
 285             NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
 286
 287         DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 288         engine.startTransaction();
 289
 290         Vertex gvnf = engine.tx().addVertex("aai-node-type", "generic-vnf", "vnf-id", "myvnf", "aai-uri",
 291                 "/network/generic-vnfs/generic-vnf/myvnf",
 292             AAIProperties.AAI_UUID, UUID.randomUUID().toString(),
 293             AAIProperties.CREATED_TS, 123,
 294             AAIProperties.SOURCE_OF_TRUTH, "sot",
 295             AAIProperties.RESOURCE_VERSION, "123",
 296             AAIProperties.LAST_MOD_SOURCE_OF_TRUTH, "lmsot",
 297             AAIProperties.LAST_MOD_TS, 333);
 298         Vertex vnfc = engine.tx().addVertex("aai-node-type", "vnfc", "vnfc-name", "a-name", "aai-uri",
 299                 "/network/vnfcs/vnfc/a-name",
 300             AAIProperties.AAI_UUID, UUID.randomUUID().toString(),
 301             AAIProperties.CREATED_TS, 123,
 302             AAIProperties.SOURCE_OF_TRUTH, "sot",
 303             AAIProperties.RESOURCE_VERSION, "123",
 304             AAIProperties.LAST_MOD_SOURCE_OF_TRUTH, "lmsot",
 305             AAIProperties.LAST_MOD_TS, 333);
 306         edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "uses");
 307
 308         Introspector relData = loader.introspectorFromName("relationship-data");
 309         relData.setValue("relationship-key", "vnfc.vnfc-name");
 310         relData.setValue("relationship-value", "a-name");
 311         Introspector relationship = loader.introspectorFromName("relationship");
 312         relationship.setValue("related-to", "vnfc");
 313         relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 314         relationship.setValue("relationship-data", relData);
 315         relationship.setValue("relationship-label", "uses");
 316         localDbser.createEdge(relationship, gvnf);
 317
 318         relationship.setValue("relationship-label", "re-uses");
 319
 320         assertNotNull(dbser.createEdge(relationship, gvnf));
 321         assertTrue(engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
 322         assertTrue(engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
 323         assertTrue(engine.tx().traversal().V(gvnf).both("uses").hasNext());
 324         assertTrue(engine.tx().traversal().V(vnfc).both("uses").hasNext());
 325         assertEquals("Number of edges between vertexes is 2", Long.valueOf(2),
 326                 engine.tx().traversal().V(vnfc).both().count().next());
 327         assertEquals("Number of edges between vertexes is 2", Long.valueOf(2),
 328                 engine.tx().traversal().V(gvnf).both().count().next());
 329
 330     }
 331
 332     @Test
 333     public void createEdgeWithNoLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException,
 334             SecurityException, IllegalArgumentException, IllegalAccessException {
 335
 336         DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 337         engine.startTransaction();
 338
 339         Vertex gvnf = engine.tx().addVertex("aai-node-type", "generic-vnf", "vnf-id", "myvnf", "aai-uri",
 340                 "/network/generic-vnfs/generic-vnf/myvnf",
 341             AAIProperties.AAI_UUID, UUID.randomUUID().toString(),
 342             AAIProperties.CREATED_TS, 123,
 343             AAIProperties.SOURCE_OF_TRUTH, "sot",
 344             AAIProperties.RESOURCE_VERSION, "123",
 345             AAIProperties.LAST_MOD_SOURCE_OF_TRUTH, "lmsot",
 346             AAIProperties.LAST_MOD_TS, 333);
 347         Vertex vnfc = engine.tx().addVertex("aai-node-type", "vnfc", "vnfc-name", "a-name", "aai-uri",
 348                 "/network/vnfcs/vnfc/a-name",
 349             AAIProperties.AAI_UUID, UUID.randomUUID().toString(),
 350             AAIProperties.CREATED_TS, 123,
 351             AAIProperties.SOURCE_OF_TRUTH, "sot",
 352             AAIProperties.RESOURCE_VERSION, "123",
 353             AAIProperties.LAST_MOD_SOURCE_OF_TRUTH, "lmsot",
 354             AAIProperties.LAST_MOD_TS, 333);
 355
 356         Introspector relData = loader.introspectorFromName("relationship-data");
 357         relData.setValue("relationship-key", "vnfc.vnfc-name");
 358         relData.setValue("relationship-value", "a-name");
 359         Introspector relationship = loader.introspectorFromName("relationship");
 360         relationship.setValue("related-to", "vnfc");
 361         relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 362         relationship.setValue("relationship-data", relData);
 363         localDbser.createEdge(relationship, gvnf);
 364
 365         assertNotNull(dbser.createEdge(relationship, gvnf));
 366         assertTrue(engine.tx().traversal().V(gvnf).both("uses").hasNext());
 367         assertTrue(engine.tx().traversal().V(vnfc).both("uses").hasNext());
 368         assertEquals("Number of edges between vertexes is 1", Long.valueOf(1),
 369                 engine.tx().traversal().V(vnfc).both().count().next());
 370         assertEquals("Number of edges between vertexes is 1", Long.valueOf(1),
 371                 engine.tx().traversal().V(gvnf).both().count().next());
 372
 373     }
 374
 375     @Test
 376     public void deleteEdgeWithNoLabelWhenMultipleExistsTest() throws AAIException, UnsupportedEncodingException,
 377             NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
 378
 379         DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 380         engine.startTransaction();
 381
 382         Vertex gvnf = engine.tx().addVertex("aai-node-type", "generic-vnf", "vnf-id", "myvnf", "aai-uri",
 383                 "/network/generic-vnfs/generic-vnf/myvnf",
 384             AAIProperties.AAI_UUID, UUID.randomUUID().toString(),
 385             AAIProperties.CREATED_TS, 123,
 386             AAIProperties.SOURCE_OF_TRUTH, "sot",
 387             AAIProperties.RESOURCE_VERSION, "123",
 388             AAIProperties.LAST_MOD_SOURCE_OF_TRUTH, "lmsot",
 389             AAIProperties.LAST_MOD_TS, 333);
 390         Vertex vnfc = engine.tx().addVertex("aai-node-type", "vnfc", "vnfc-name", "a-name", "aai-uri",
 391                 "/network/vnfcs/vnfc/a-name",
 392             AAIProperties.AAI_UUID, UUID.randomUUID().toString(),
 393             AAIProperties.CREATED_TS, 123,
 394             AAIProperties.SOURCE_OF_TRUTH, "sot",
 395             AAIProperties.RESOURCE_VERSION, "123",
 396             AAIProperties.LAST_MOD_SOURCE_OF_TRUTH, "lmsot",
 397             AAIProperties.LAST_MOD_TS, 333);
 398         edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "uses");
 399         edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "re-uses");
 400         edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "over-uses");
 401
 402         Introspector relData = loader.introspectorFromName("relationship-data");
 403         relData.setValue("relationship-key", "vnfc.vnfc-name");
 404         relData.setValue("relationship-value", "a-name");
 405         Introspector relationship = loader.introspectorFromName("relationship");
 406         relationship.setValue("related-to", "vnfc");
 407         relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 408         relationship.setValue("relationship-data", relData);
 409
 410         assertTrue(localDbser.deleteEdge(relationship, gvnf).isPresent());
 411         assertFalse("generic-vnf has no edge uses", engine.tx().traversal().V(gvnf).both("uses").hasNext());
 412         assertFalse("vnfc has no edge uses", engine.tx().traversal().V(vnfc).both("uses").hasNext());
 413         assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
 414         assertTrue("vnfc has edge re-uses", engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
 415         assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V(gvnf).both("over-uses").hasNext());
 416         assertTrue("vnfc has edge re-uses", engine.tx().traversal().V(vnfc).both("over-uses").hasNext());
 417         assertEquals("Number of edges between vertexes is 2", Long.valueOf(2),
 418                 engine.tx().traversal().V(vnfc).both().count().next());
 419         assertEquals("Number of edges between vertexes is 2", Long.valueOf(2),
 420                 engine.tx().traversal().V(gvnf).both().count().next());
 421
 422     }
 423
 424     @Test
 425     public void deleteEdgeWithValidLabelWhenMultipleExistsTest() throws AAIException, UnsupportedEncodingException,
 426             NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
 427
 428         DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 429
 430         engine.startTransaction();
 431
 432         Vertex gvnf = engine.tx().addVertex("aai-node-type", "generic-vnf", "vnf-id", "myvnf", "aai-uri",
 433                 "/network/generic-vnfs/generic-vnf/myvnf",
 434             AAIProperties.AAI_UUID, UUID.randomUUID().toString(),
 435             AAIProperties.CREATED_TS, 123,
 436             AAIProperties.SOURCE_OF_TRUTH, "sot",
 437             AAIProperties.RESOURCE_VERSION, "123",
 438             AAIProperties.LAST_MOD_SOURCE_OF_TRUTH, "lmsot",
 439             AAIProperties.LAST_MOD_TS, 333);
 440         Vertex vnfc = engine.tx().addVertex("aai-node-type", "vnfc", "vnfc-name", "a-name", "aai-uri",
 441                 "/network/vnfcs/vnfc/a-name",
 442             AAIProperties.AAI_UUID, UUID.randomUUID().toString(),
 443             AAIProperties.CREATED_TS, 123,
 444             AAIProperties.SOURCE_OF_TRUTH, "sot",
 445             AAIProperties.RESOURCE_VERSION, "123",
 446             AAIProperties.LAST_MOD_SOURCE_OF_TRUTH, "lmsot",
 447             AAIProperties.LAST_MOD_TS, 333);
 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");
 451
 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", "re-uses");
 460
 461         assertTrue(localDbser.deleteEdge(relationship, gvnf).isPresent());
 462         assertTrue("generic-vnf has edge uses", engine.tx().traversal().V(gvnf).both("uses").hasNext());
 463         assertTrue("vnfc has edge uses", engine.tx().traversal().V(vnfc).both("uses").hasNext());
 464         assertFalse("generic-vnf has no edge re-uses", engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
 465         assertFalse("vnfc has no edge re-uses", engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
 466         assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V(gvnf).both("over-uses").hasNext());
 467         assertTrue("vnfc has edge re-uses", engine.tx().traversal().V(vnfc).both("over-uses").hasNext());
 468         assertEquals("Number of edges between vertexes is 2", Long.valueOf(2),
 469                 engine.tx().traversal().V(vnfc).both().count().next());
 470         assertEquals("Number of edges between vertexes is 2", Long.valueOf(2),
 471                 engine.tx().traversal().V(gvnf).both().count().next());
 472
 473     }
 474
 475     @Test
 476     public void deleteEdgeWithValidInvalidLabelWhenMultipleExistsTest()
 477             throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException,
 478             IllegalArgumentException, IllegalAccessException {
 479
 480         DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 481
 482         engine.startTransaction();
 483
 484         Vertex gvnf = engine.tx().addVertex("aai-node-type", "generic-vnf", "vnf-id", "myvnf", "aai-uri",
 485                 "/network/generic-vnfs/generic-vnf/myvnf");
 486         Vertex vnfc = engine.tx().addVertex("aai-node-type", "vnfc", "vnfc-name", "a-name", "aai-uri",
 487                 "/network/vnfcs/vnfc/a-name");
 488         edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "uses");
 489         edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "re-uses");
 490         edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "over-uses");
 491
 492         Introspector relData = loader.introspectorFromName("relationship-data");
 493         relData.setValue("relationship-key", "vnfc.vnfc-name");
 494         relData.setValue("relationship-value", "a-name");
 495         Introspector relationship = loader.introspectorFromName("relationship");
 496         relationship.setValue("related-to", "vnfc");
 497         relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 498         relationship.setValue("relationship-data", relData);
 499         relationship.setValue("relationship-label", "NA");
 500
 501         thrown.expect(AAIException.class);
 502         thrown.expectMessage("No rule found");
 503         thrown.expectMessage("node type: generic-vnf, node type: vnfc, label: NA, type: COUSIN");
 504         localDbser.deleteEdge(relationship, gvnf);
 505     }
 506
 507     @Test
 508     public void serializeToDbWithLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException,
 509             SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
 510
 511         DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 512
 513         engine.startTransaction();
 514
 515         engine.tx().addVertex("aai-node-type", "vnfc", "vnfc-name", "a-name", "aai-uri", "/network/vnfcs/vnfc/a-name", "aai-uuid", "b",
 516             AAIProperties.CREATED_TS, 123,
 517             AAIProperties.SOURCE_OF_TRUTH, "sot",
 518             AAIProperties.RESOURCE_VERSION, "123",
 519             AAIProperties.LAST_MOD_SOURCE_OF_TRUTH, "lmsot",
 520             AAIProperties.LAST_MOD_TS, 333);
 521
 522         Introspector relationship = loader.introspectorFromName("relationship");
 523         relationship.setValue("related-to", "vnfc");
 524         relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 525         relationship.setValue("relationship-label", "re-uses");
 526         Introspector relationshipList = loader.introspectorFromName("relationship-list");
 527         relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
 528
 529         Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
 530         Vertex gvnf = localDbser.createNewVertex(gvnfObj);
 531         gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
 532         gvnfObj.setValue("vnf-id", "myvnf");
 533
 534         QueryParser uriQuery =
 535                 dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
 536
 537         localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 538
 539         assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
 540         assertTrue("vertex with vnfc-name a-name exists",
 541                 engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
 542         assertFalse("generic-vnf has no edge re-uses",
 543                 engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
 544         assertFalse("vnfc has no edge re-uses",
 545                 engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
 546         assertTrue("generic-vnf has edge re-uses",
 547                 engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
 548         assertTrue("vnfc has edge re-uses",
 549                 engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
 550         assertFalse("generic-vnf has no edge re-uses",
 551                 engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
 552         assertFalse("vnfc has no edge re-uses",
 553                 engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
 554         assertEquals("Number of edges between vertexes is 1", Long.valueOf(1),
 555                 engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
 556         assertEquals("Number of edges between vertexes is 1", Long.valueOf(1),
 557                 engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
 558
 559     }
 560
 561     @Test
 562     public void serializeToDbWithoutLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException,
 563             SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
 564
 565         DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 566
 567         engine.startTransaction();
 568
 569         engine.tx().addVertex("aai-node-type", "vnfc", "vnfc-name", "a-name", "aai-uri", "/network/vnfcs/vnfc/a-name",
 570             AAIProperties.AAI_UUID, UUID.randomUUID().toString(),
 571             AAIProperties.CREATED_TS, 123,
 572             AAIProperties.SOURCE_OF_TRUTH, "sot",
 573             AAIProperties.RESOURCE_VERSION, "123",
 574             AAIProperties.LAST_MOD_SOURCE_OF_TRUTH, "lmsot",
 575             AAIProperties.LAST_MOD_TS, 333);
 576
 577         Introspector relationship = loader.introspectorFromName("relationship");
 578         relationship.setValue("related-to", "vnfc");
 579         relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 580
 581         Introspector relationshipList = loader.introspectorFromName("relationship-list");
 582         relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
 583
 584         Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
 585         Vertex gvnf = localDbser.createNewVertex(gvnfObj);
 586         gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
 587         gvnfObj.setValue("vnf-id", "myvnf");
 588
 589         QueryParser uriQuery =
 590                 dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
 591
 592         localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 593
 594         assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
 595         assertTrue("vertex with vnfc-name a-name exists",
 596                 engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
 597         assertTrue("generic-vnf has edge uses",
 598                 engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
 599         assertTrue("vnfc has edge uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
 600         assertFalse("generic-vnf has no edge re-uses",
 601                 engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
 602         assertFalse("vnfc has no edge re-uses",
 603                 engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
 604         assertFalse("generic-vnf has no edge over-uses",
 605                 engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
 606         assertFalse("vnfc has no edge over-uses",
 607                 engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
 608         assertEquals("Number of edges between vertexes is 1", Long.valueOf(1),
 609                 engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
 610         assertEquals("Number of edges between vertexes is 1", Long.valueOf(1),
 611                 engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
 612
 613     }
 614
 615     @Test
 616     public void serializeToDbWithInvalidLabelTest()
 617             throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException,
 618             IllegalArgumentException, IllegalAccessException, URISyntaxException {
 619
 620         DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 621
 622         engine.startTransaction();
 623
 624         engine.tx().addVertex("aai-node-type", "vnfc", "vnfc-name", "a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
 625
 626         Introspector relationship = loader.introspectorFromName("relationship");
 627         relationship.setValue("related-to", "vnfc");
 628         relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 629         relationship.setValue("relationship-label", "NA");
 630         Introspector relationshipList = loader.introspectorFromName("relationship-list");
 631         relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
 632
 633         Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
 634         Vertex gvnf = localDbser.createNewVertex(gvnfObj);
 635         gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
 636         gvnfObj.setValue("vnf-id", "myvnf");
 637
 638         QueryParser uriQuery =
 639                 dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
 640
 641         thrown.expect(AAIException.class);
 642         thrown.expectMessage("No EdgeRule found for passed nodeTypes: generic-vnf, vnfc with label NA.");
 643         localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 644
 645     }
 646
 647     @Test
 648     public void serializeToDbWithLabelAndEdgeExistsTest()
 649             throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException,
 650             IllegalArgumentException, IllegalAccessException, URISyntaxException {
 651
 652         DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 653
 654         engine.startTransaction();
 655         engine.tx().addVertex("aai-node-type", "vnfc", "vnfc-name", "a-name", "aai-uri", "/network/vnfcs/vnfc/a-name",
 656             AAIProperties.AAI_UUID, UUID.randomUUID().toString(),
 657             AAIProperties.CREATED_TS, 123,
 658             AAIProperties.SOURCE_OF_TRUTH, "sot",
 659             AAIProperties.RESOURCE_VERSION, "123",
 660             AAIProperties.LAST_MOD_SOURCE_OF_TRUTH, "lmsot",
 661             AAIProperties.LAST_MOD_TS, 333);
 662
 663         Introspector relationship;
 664         Introspector relationshipList;
 665         List<Object> relList = new ArrayList<>();
 666
 667         // create generic-vnf
 668         Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
 669         Vertex gvnf = localDbser.createNewVertex(gvnfObj);
 670         gvnfObj.setValue("vnf-id", "myvnf");
 671         QueryParser uriQuery =
 672                 dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
 673
 674         // create relationship to vnfc
 675         relationship = loader.introspectorFromName("relationship");
 676         relationship.setValue("related-to", "vnfc");
 677         relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 678         relList.add(relationship.getUnderlyingObject());
 679         relationshipList = loader.introspectorFromName("relationship-list");
 680         relationshipList.setValue("relationship", relList);
 681         gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
 682
 683         // add gvnf to graph
 684         localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 685
 686         // add second relationship
 687         relationship = loader.introspectorFromName("relationship");
 688         relationship.setValue("related-to", "vnfc");
 689         relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 690         relationship.setValue("relationship-label", "re-uses");
 691         relList.add(relationship.getUnderlyingObject());
 692         relationshipList = loader.introspectorFromName("relationship-list");
 693         relationshipList.setValue("relationship", relList);
 694         gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
 695
 696         localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 697
 698         assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
 699         assertTrue("vertex with vnfc-name a-name exists",
 700                 engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
 701         assertTrue("generic-vnf has  edge uses",
 702                 engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
 703         assertTrue("vnfc has  edge uses",
 704                 engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
 705         assertTrue("generic-vnf has edge re-uses",
 706                 engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
 707         assertTrue("vnfc has edge re-uses",
 708                 engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
 709         assertFalse("generic-vnf has no edge over-uses",
 710                 engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
 711         assertFalse("vnfc has no edge over-uses",
 712                 engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
 713         assertEquals("Number of edges between vertexes is 2", Long.valueOf(2),
 714                 engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
 715         assertEquals("Number of edges between vertexes is 2", Long.valueOf(2),
 716                 engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
 717
 718     }
 719
 720     @Test
 721     public void serializeToDbWithLabelDroppingRelationshipTest()
 722             throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException,
 723             IllegalArgumentException, IllegalAccessException, URISyntaxException {
 724
 725         DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 726
 727         engine.startTransaction();
 728         engine.tx().addVertex("aai-node-type", "vnfc", "vnfc-name", "a-name", "aai-uri", "/network/vnfcs/vnfc/a-name",
 729             AAIProperties.AAI_UUID, UUID.randomUUID().toString(),
 730             AAIProperties.CREATED_TS, 123,
 731             AAIProperties.SOURCE_OF_TRUTH, "sot",
 732             AAIProperties.RESOURCE_VERSION, "123",
 733             AAIProperties.LAST_MOD_SOURCE_OF_TRUTH, "lmsot",
 734             AAIProperties.LAST_MOD_TS, 333);
 735
 736         Introspector relationship;
 737         Introspector relationshipList;
 738         List<Object> relList = new ArrayList<>();
 739
 740         // create generic-vnf
 741         Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
 742         Vertex gvnf = localDbser.createNewVertex(gvnfObj);
 743         gvnfObj.setValue("vnf-id", "myvnf");
 744         QueryParser uriQuery =
 745                 dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
 746
 747         // create relationship to vnfc
 748         relationship = loader.introspectorFromName("relationship");
 749         relationship.setValue("related-to", "vnfc");
 750         relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 751         relList.add(relationship.getUnderlyingObject());
 752         // add second relationship
 753         relationship = loader.introspectorFromName("relationship");
 754         relationship.setValue("related-to", "vnfc");
 755         relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 756         relationship.setValue("relationship-label", "re-uses");
 757         relList.add(relationship.getUnderlyingObject());
 758         relationshipList = loader.introspectorFromName("relationship-list");
 759         relationshipList.setValue("relationship", relList);
 760         gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
 761
 762         // add gvnf to graph
 763         localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 764
 765         // drop second relationship
 766         relList.remove(1);
 767         relationshipList = loader.introspectorFromName("relationship-list");
 768         relationshipList.setValue("relationship", relList);
 769         gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
 770
 771         localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 772
 773         assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
 774         assertTrue("vertex with vnfc-name a-name exists",
 775                 engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
 776         assertTrue("generic-vnf has  edge uses",
 777                 engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
 778         assertTrue("vnfc has  edge uses",
 779                 engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
 780         assertFalse("generic-vnf no longer has edge re-uses",
 781                 engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
 782         assertFalse("vnfc no longer has edge re-uses",
 783                 engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
 784         assertFalse("generic-vnf has no edge over-uses",
 785                 engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
 786         assertFalse("vnfc has no edge over-uses",
 787                 engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
 788         assertEquals("Number of edges between vertexes is 1", Long.valueOf(1),
 789                 engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
 790         assertEquals("Number of edges between vertexes is 1", Long.valueOf(1),
 791                 engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
 792
 793     }
 794
 795     private DBSerializer getDBSerializerWithSpecificEdgeRules() throws AAIException {
 796
 797         return new DBSerializer(version, engine, introspectorFactoryType, "AAI-TEST");
 798     }
 799 }