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 static org.junit.Assert.*;
  24 import static org.mockito.Mockito.spy;
  25 import static org.mockito.Mockito.when;
  26
  27 import java.io.UnsupportedEncodingException;
  28 import java.net.URI;
  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;
  34
  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;
  40 import org.junit.*;
  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;
  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,
  73                 XmlFormatTransformerConfiguration.class})
  74 @TestPropertySource(
  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 {
  78
  79     // to use, set thrown.expect to whatever your test needs
  80     // this line establishes default of expecting no exception to be thrown
  81     @Rule
  82     public ExpectedException thrown = ExpectedException.none();
  83
  84     protected static Graph graph;
  85
  86     @Autowired
  87     protected EdgeSerializer edgeSer;
  88     @Autowired
  89     protected EdgeIngestor ei;
  90     @Autowired
  91     protected SchemaVersions schemaVersions;
  92
  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;
 101
 102     public QueryStyle queryStyle = QueryStyle.TRAVERSAL;
 103
 104     @BeforeClass
 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/");
 111
 112     }
 113
 114     @Before
 115     public void setup() throws Exception {
 116         version = schemaVersions.getDefaultVersion();
 117         loader = SpringContextAware.getBean(LoaderFactory.class).createLoaderForVersion(introspectorFactoryType,
 118                 version);
 119         dbEngine = new JanusGraphDBEngine(queryStyle, loader);
 120         spy = spy(dbEngine);
 121         adminSpy = spy(dbEngine.asAdmin());
 122
 123         engine = new JanusGraphDBEngine(queryStyle, loader);
 124         dbser = new DBSerializer(version, engine, introspectorFactoryType, "AAI-TEST");
 125     }
 126
 127     @After
 128     public void tearDown() throws Exception {
 129         engine.rollback();
 130     }
 131
 132     @AfterClass
 133     public static void destroy() throws Exception {
 134         graph.close();
 135     }
 136
 137     public void subnetSetup() throws AAIException {
 138         /*
 139          * This setus up the test graph, For future junits , add more vertices
 140          * and edges
 141          */
 142
 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");
 152
 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);
 157     }
 158
 159     public String testDelete(Vertex v) throws AAIException {
 160
 161         GraphTraversalSource traversal = graph.traversal();
 162         when(spy.asAdmin()).thenReturn(adminSpy);
 163         when(adminSpy.getTraversalSource()).thenReturn(traversal);
 164         when(adminSpy.getReadOnlyTraversalSource()).thenReturn(traversal);
 165
 166         String exceptionMessage = "";
 167         DBSerializer serializer = new DBSerializer(version, spy, introspectorFactoryType, "AAI_TEST");
 168         try {
 169             serializer.delete(v, "resourceVersion", false);
 170         } catch (AAIException exception) {
 171             exceptionMessage = exception.getMessage();
 172         }
 173         return exceptionMessage;
 174
 175     }
 176
 177     @Test
 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();
 183
 184         engine.startTransaction();
 185
 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);
 190
 191         Introspector relationship = loader.introspectorFromName("relationship");
 192         relationship.setValue("related-to", "vnfc");
 193         relationship.setValue("related-link", "/network/vnfcs/vnfc/vnfc-" + testName);
 194
 195         Introspector relationshipList = loader.introspectorFromName("relationship-list");
 196         relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
 197
 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);
 202
 203         QueryParser uriQuery = dbEngine.getQueryBuilder()
 204                 .createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/vnf-" + testName));
 205
 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());
 209
 210     }
 211
 212     @Test
 213     public void createEdgeWithValidLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException,
 214             SecurityException, IllegalArgumentException, IllegalAccessException {
 215
 216         DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 217
 218         engine.startTransaction();
 219
 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);
 228
 229         // sunny day case
 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");
 238
 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());
 242
 243     }
 244
 245     @Test
 246     public void createEdgeWithValidLabelWhenSameEdgeExistsTest() throws AAIException, UnsupportedEncodingException,
 247             NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
 248
 249         DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 250         engine.startTransaction();
 251
 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");
 257
 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");
 266
 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());
 272
 273     }
 274
 275     @Test
 276     public void createEdgeWithValidLabelWhenDiffEdgeExistsTest() throws AAIException, UnsupportedEncodingException,
 277             NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
 278
 279         DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 280         engine.startTransaction();
 281
 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");
 291
 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);
 301
 302         relationship.setValue("relationship-label", "re-uses");
 303
 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());
 313
 314     }
 315
 316     @Test
 317     public void createEdgeWithNoLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException,
 318             SecurityException, IllegalArgumentException, IllegalAccessException {
 319
 320         DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 321         engine.startTransaction();
 322
 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);
 331
 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);
 340
 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());
 348
 349     }
 350
 351     @Test
 352     public void deleteEdgeWithNoLabelWhenMultipleExistsTest() throws AAIException, UnsupportedEncodingException,
 353             NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
 354
 355         DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 356         engine.startTransaction();
 357
 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");
 369
 370         Introspector relData = loader.introspectorFromName("relationship-data");
 371         relData.setValue("relationship-key", "vnfc.vnfc-name");
 372         relData.setValue("relationship-value", "a-name");
 373         Introspector relationship = loader.introspectorFromName("relationship");
 374         relationship.setValue("related-to", "vnfc");
 375         relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 376         relationship.setValue("relationship-data", relData);
 377
 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());
 389
 390     }
 391
 392     @Test
 393     public void deleteEdgeWithValidLabelWhenMultipleExistsTest() throws AAIException, UnsupportedEncodingException,
 394             NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
 395
 396         DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 397
 398         engine.startTransaction();
 399
 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");
 411
 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");
 420
 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());
 432
 433     }
 434
 435     @Test
 436     public void deleteEdgeWithValidInvalidLabelWhenMultipleExistsTest()
 437             throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException,
 438             IllegalArgumentException, IllegalAccessException {
 439
 440         DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 441
 442         engine.startTransaction();
 443
 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");
 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", "NA");
 460
 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);
 465     }
 466
 467     @Test
 468     public void serializeToDbWithLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException,
 469             SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
 470
 471         DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 472
 473         engine.startTransaction();
 474
 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);
 479
 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()));
 486
 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");
 491
 492         QueryParser uriQuery =
 493                 dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
 494
 495         localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 496
 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());
 516
 517     }
 518
 519     @Test
 520     public void serializeToDbWithoutLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException,
 521             SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
 522
 523         DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 524
 525         engine.startTransaction();
 526
 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);
 531
 532         Introspector relationship = loader.introspectorFromName("relationship");
 533         relationship.setValue("related-to", "vnfc");
 534         relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 535
 536         Introspector relationshipList = loader.introspectorFromName("relationship-list");
 537         relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
 538
 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");
 543
 544         QueryParser uriQuery =
 545                 dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
 546
 547         localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 548
 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());
 567
 568     }
 569
 570     @Test
 571     public void serializeToDbWithInvalidLabelTest()
 572             throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException,
 573             IllegalArgumentException, IllegalAccessException, URISyntaxException {
 574
 575         DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 576
 577         engine.startTransaction();
 578
 579         engine.tx().addVertex("aai-node-type", "vnfc", "vnfc-name", "a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
 580
 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()));
 587
 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");
 592
 593         QueryParser uriQuery =
 594                 dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
 595
 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");
 599
 600     }
 601
 602     @Test
 603     public void serializeToDbWithLabelAndEdgeExistsTest()
 604             throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException,
 605             IllegalArgumentException, IllegalAccessException, URISyntaxException {
 606
 607         DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 608
 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);
 614
 615         Introspector relationship;
 616         Introspector relationshipList;
 617         List<Object> relList = new ArrayList<>();
 618
 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"));
 625
 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());
 634
 635         // add gvnf to graph
 636         localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 637
 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());
 647
 648         localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 649
 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());
 669
 670     }
 671
 672     @Test
 673     public void serializeToDbWithLabelDroppingRelationshipTest()
 674             throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException,
 675             IllegalArgumentException, IllegalAccessException, URISyntaxException {
 676
 677         DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 678
 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);
 684
 685         Introspector relationship;
 686         Introspector relationshipList;
 687         List<Object> relList = new ArrayList<>();
 688
 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"));
 695
 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());
 710
 711         // add gvnf to graph
 712         localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 713
 714         // drop second relationship
 715         relList.remove(1);
 716         relationshipList = loader.introspectorFromName("relationship-list");
 717         relationshipList.setValue("relationship", relList);
 718         gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
 719
 720         localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 721
 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());
 741
 742     }
 743
 744     private DBSerializer getDBSerializerWithSpecificEdgeRules() throws AAIException {
 745
 746         return new DBSerializer(version, engine, introspectorFactoryType, "AAI-TEST");
 747     }
 748 }