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 package org.onap.aai.serialization.db;
  21
  22 import org.onap.aai.config.ConfigConfiguration;
  23 import org.onap.aai.setup.SchemaVersion;
  24 import org.onap.aai.setup.SchemaVersions;
  25 import org.onap.aai.util.AAIConstants;
  26 import org.janusgraph.core.JanusGraphFactory;
  27 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
  28 import org.apache.tinkerpop.gremlin.structure.*;
  29 import org.junit.*;
  30 import org.junit.rules.ExpectedException;
  31 import org.junit.runner.RunWith;
  32 import org.onap.aai.config.IntrospectionConfig;
  33 import org.onap.aai.config.SpringContextAware;
  34 import org.onap.aai.db.props.AAIProperties;
  35 import org.onap.aai.dbmap.DBConnectionType;
  36 import org.onap.aai.edges.EdgeIngestor;
  37 import org.onap.aai.exceptions.AAIException;
  38 import org.onap.aai.introspection.*;
  39 import org.onap.aai.nodes.NodeIngestor;
  40 import org.onap.aai.parsers.query.QueryParser;
  41 import org.onap.aai.serialization.engines.QueryStyle;
  42 import org.onap.aai.serialization.engines.JanusGraphDBEngine;
  43 import org.onap.aai.serialization.engines.TransactionalGraphEngine;
  44 import org.onap.aai.serialization.queryformats.QueryFormatTestHelper;
  45 import org.onap.aai.setup.SchemaLocationsBean;
  46 import org.springframework.beans.factory.annotation.Autowired;
  47 import org.springframework.test.context.ContextConfiguration;
  48 import org.springframework.test.context.TestPropertySource;
  49 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  50
  51 import java.io.UnsupportedEncodingException;
  52 import java.net.URI;
  53 import java.net.URISyntaxException;
  54 import java.util.*;
  55
  56 import static org.junit.Assert.*;
  57 import static org.mockito.Mockito.spy;
  58 import static org.mockito.Mockito.when;
  59
  60 //@RunWith(value = Parameterized.class) TODO replace this functionality
  61 @RunWith(SpringJUnit4ClassRunner.class)
  62 @ContextConfiguration(classes = {
  63                 ConfigConfiguration.class,
  64                 AAICoreFakeEdgesConfigTranslator.class,
  65                 NodeIngestor.class,
  66                 EdgeIngestor.class,
  67                 EdgeSerializer.class,
  68                 SpringContextAware.class,
  69                 IntrospectionConfig.class
  70 })
  71 @TestPropertySource(properties = {
  72     "schema.translator.list = config",
  73     "schema.nodes.location=src/test/resources/onap/oxm",
  74     "schema.edges.location=src/test/resources/onap/dbedgerules"
  75 })
  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 final DBConnectionType type = DBConnectionType.REALTIME;
  95         private Loader loader;
  96         private TransactionalGraphEngine dbEngine;
  97         private TransactionalGraphEngine engine; //for tests that aren't mocking the engine
  98         private DBSerializer dbser;
  99         TransactionalGraphEngine spy;
 100         TransactionalGraphEngine.Admin adminSpy;
 101
 102         //@Parameterized.Parameter(value = 0)
 103         public QueryStyle queryStyle = QueryStyle.TRAVERSAL;
 104
 105         /*@Parameterized.Parameters(name = "QueryStyle.{0}")
 106         public static Collection<Object[]> data() {
 107                 return Arrays.asList(new Object[][]{
 108                                 {QueryStyle.TRAVERSAL},
 109                                 {QueryStyle.TRAVERSAL_URI}
 110                 });
 111         }*/
 112
 113         @BeforeClass
 114         public static void init() throws Exception {
 115                 graph = JanusGraphFactory.build().set("storage.backend", "inmemory").open();
 116                 System.setProperty("AJSC_HOME", ".");
 117         System.setProperty("BUNDLECONFIG_DIR", "src/test/resources/bundleconfig-local");
 118         QueryFormatTestHelper.setFinalStatic(AAIConstants.class.getField("AAI_HOME_ETC_OXM"), "src/test/resources/bundleconfig-local/etc/oxm/");
 119
 120         }
 121
 122         @Before
 123         public void setup() throws Exception {
 124                 //createGraph();
 125         version = schemaVersions.getDefaultVersion();
 126                 loader = SpringContextAware.getBean(LoaderFactory.class).createLoaderForVersion(introspectorFactoryType, version);
 127                 dbEngine = new JanusGraphDBEngine(queryStyle, type, loader);
 128                 spy = spy(dbEngine);
 129                 adminSpy = spy(dbEngine.asAdmin());
 130
 131
 132                 engine = new JanusGraphDBEngine(queryStyle, type, loader);
 133                 dbser = new DBSerializer(version, engine, introspectorFactoryType, "AAI-TEST");
 134         }
 135
 136         @After
 137         public void tearDown() throws Exception {
 138             engine.rollback();
 139         }
 140
 141         @AfterClass
 142         public static void destroy() throws Exception {
 143                 graph.close();
 144         }
 145
 146         public void subnetSetup() throws AAIException {
 147                 /*
 148                  * This setus up the test graph, For future junits , add more vertices
 149                  * and edges
 150                  */
 151
 152                 Vertex l3interipv4addresslist_1 = graph.traversal().addV("aai-node-type", "l3-interface-ipv4-address-list",
 153                                 "l3-interface-ipv4-address", "l3-interface-ipv4-address-1").next();
 154                 Vertex subnet_2 = graph.traversal().addV("aai-node-type", "subnet", "subnet-id", "subnet-id-2").next();
 155                 Vertex l3interipv6addresslist_3 = graph.traversal().addV("aai-node-type", "l3-interface-ipv6-address-list",
 156                                 "l3-interface-ipv6-address", "l3-interface-ipv6-address-3").next();
 157                 Vertex subnet_4 = graph.traversal().addV("aai-node-type", "subnet", "subnet-id", "subnet-id-4").next();
 158                 Vertex subnet_5 = graph.traversal().addV("aai-node-type", "subnet", "subnet-id", "subnet-id-5").next();
 159                 Vertex l3network_6 = graph.traversal()
 160                                 .addV("aai-node-type", "l3-network", "network-id", "network-id-6", "network-name", "network-name-6")
 161                                 .next();
 162
 163                 GraphTraversalSource g = graph.traversal();
 164                 edgeSer.addEdge(g, l3interipv4addresslist_1, subnet_2);
 165                 edgeSer.addEdge(g, l3interipv6addresslist_3, subnet_4);
 166                 edgeSer.addTreeEdge(g, subnet_5, l3network_6);
 167         }
 168
 169         public String testDelete(Vertex v) throws AAIException {
 170
 171                 GraphTraversalSource traversal = graph.traversal();
 172                 when(spy.asAdmin()).thenReturn(adminSpy);
 173                 when(adminSpy.getTraversalSource()).thenReturn(traversal);
 174                 when(adminSpy.getReadOnlyTraversalSource()).thenReturn(traversal);
 175
 176                 String exceptionMessage = "";
 177                 DBSerializer serializer = new DBSerializer(version, spy, introspectorFactoryType, "AAI_TEST");
 178                 try {
 179                         serializer.delete(v, "resourceVersion", false);
 180                 } catch (AAIException exception) {
 181                         exceptionMessage = exception.getMessage();
 182                 }
 183                 return exceptionMessage;
 184
 185         }
 186
 187         @Test
 188         public void serializeToDbNewVertexAndEdgeAAIUUIDTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
 189                 String testName = new Object() {}.getClass().getEnclosingMethod().getName();
 190                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 191
 192                 engine.startTransaction();
 193
 194                 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","vnfc-" + testName, AAIProperties.AAI_URI, "/network/vnfcs/vnfc/vnfc-" + testName);
 195
 196                 Introspector relationship = loader.introspectorFromName("relationship");
 197                 relationship.setValue("related-to", "vnfc");
 198                 relationship.setValue("related-link", "/network/vnfcs/vnfc/vnfc-" + testName);
 199
 200                 Introspector relationshipList = loader.introspectorFromName("relationship-list");
 201                 relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
 202
 203                 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
 204                 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
 205                 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
 206                 gvnfObj.setValue("vnf-id", "vnf-" + testName);
 207
 208                 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/vnf-" + testName));
 209
 210                 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 211                 assertTrue("Generic-vnf has uuid ", gvnf.property(AAIProperties.AAI_UUID).isPresent());
 212                 assertTrue("Edge has uuid ", gvnf.edges(Direction.BOTH).next().property(AAIProperties.AAI_UUID).isPresent());
 213
 214         }
 215
 216         @Test
 217         public void createEdgeWithValidLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
 218
 219                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 220
 221                 engine.startTransaction();
 222
 223                 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf", "aai-uri", "/network/generic-vnfs/generic-vnf/myvnf");
 224                 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
 225
 226                 //sunny day case
 227                 Introspector relData = loader.introspectorFromName("relationship-data");
 228                 relData.setValue("relationship-key", "vnfc.vnfc-name");
 229                 relData.setValue("relationship-value", "a-name");
 230                 Introspector relationship = loader.introspectorFromName("relationship");
 231                 relationship.setValue("related-to", "vnfc");
 232                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 233                 relationship.setValue("relationship-data",relData);
 234                 relationship.setValue("relationship-label", "over-uses");
 235
 236                 assertTrue(localDbser.createEdge(relationship, gvnf));
 237                 assertTrue(engine.tx().traversal().V(gvnf).both("over-uses").hasNext());
 238                 assertTrue(engine.tx().traversal().V(vnfc).both("over-uses").hasNext());
 239
 240         }
 241
 242         @Test
 243         public void createEdgeWithValidLabelWhenSameEdgeExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
 244
 245                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 246                 engine.startTransaction();
 247
 248                 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf", "aai-uri", "/network/generic-vnfs/generic-vnf/myvnf");
 249                 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
 250                 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "re-uses");
 251
 252                 Introspector relData = loader.introspectorFromName("relationship-data");
 253                 relData.setValue("relationship-key", "vnfc.vnfc-name");
 254                 relData.setValue("relationship-value", "a-name");
 255                 Introspector relationship = loader.introspectorFromName("relationship");
 256                 relationship.setValue("related-to", "vnfc");
 257                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 258                 relationship.setValue("relationship-data",relData);
 259                 relationship.setValue("relationship-label", "re-uses");
 260
 261                 assertTrue(localDbser.createEdge(relationship, gvnf));
 262                 assertTrue(engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
 263                 assertTrue(engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
 264                 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V(vnfc).both().count().next());
 265
 266         }
 267
 268         @Test
 269         public void createEdgeWithValidLabelWhenDiffEdgeExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
 270
 271                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 272                 engine.startTransaction();
 273
 274                 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf", "aai-uri", "/network/generic-vnfs/generic-vnf/myvnf");
 275                 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
 276                 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "uses");
 277
 278                 Introspector relData = loader.introspectorFromName("relationship-data");
 279                 relData.setValue("relationship-key", "vnfc.vnfc-name");
 280                 relData.setValue("relationship-value", "a-name");
 281                 Introspector relationship = loader.introspectorFromName("relationship");
 282                 relationship.setValue("related-to", "vnfc");
 283                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 284                 relationship.setValue("relationship-data",relData);
 285                 relationship.setValue("relationship-label", "uses");
 286                 localDbser.createEdge(relationship, gvnf);
 287
 288                 relationship.setValue("relationship-label", "re-uses");
 289
 290                 assertTrue(localDbser.createEdge(relationship, gvnf));
 291                 assertTrue(engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
 292                 assertTrue(engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
 293                 assertTrue(engine.tx().traversal().V(gvnf).both("uses").hasNext());
 294                 assertTrue(engine.tx().traversal().V(vnfc).both("uses").hasNext());
 295                 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(vnfc).both().count().next());
 296                 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(gvnf).both().count().next());
 297
 298         }
 299
 300         @Test
 301         public void createEdgeWithNoLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
 302
 303                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 304                 engine.startTransaction();
 305
 306                 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf", "aai-uri", "/network/generic-vnfs/generic-vnf/myvnf");
 307                 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
 308
 309                 Introspector relData = loader.introspectorFromName("relationship-data");
 310                 relData.setValue("relationship-key", "vnfc.vnfc-name");
 311                 relData.setValue("relationship-value", "a-name");
 312                 Introspector relationship = loader.introspectorFromName("relationship");
 313                 relationship.setValue("related-to", "vnfc");
 314                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 315                 relationship.setValue("relationship-data",relData);
 316                 localDbser.createEdge(relationship, gvnf);
 317
 318                 assertTrue(localDbser.createEdge(relationship, gvnf));
 319                 assertTrue(engine.tx().traversal().V(gvnf).both("uses").hasNext());
 320                 assertTrue(engine.tx().traversal().V(vnfc).both("uses").hasNext());
 321                 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V(vnfc).both().count().next());
 322                 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V(gvnf).both().count().next());
 323
 324
 325         }
 326
 327         @Test
 328         public void deleteEdgeWithNoLabelWhenMultipleExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
 329
 330                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 331                 engine.startTransaction();
 332
 333                 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf", "aai-uri", "/network/generic-vnfs/generic-vnf/myvnf");
 334                 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
 335                 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "uses");
 336                 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "re-uses");
 337                 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "over-uses");
 338
 339                 Introspector relData = loader.introspectorFromName("relationship-data");
 340                 relData.setValue("relationship-key", "vnfc.vnfc-name");
 341                 relData.setValue("relationship-value", "a-name");
 342                 Introspector relationship = loader.introspectorFromName("relationship");
 343                 relationship.setValue("related-to", "vnfc");
 344                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 345                 relationship.setValue("relationship-data",relData);
 346
 347                 assertTrue(localDbser.deleteEdge(relationship, gvnf));
 348                 assertFalse("generic-vnf has no edge uses", engine.tx().traversal().V(gvnf).both("uses").hasNext());
 349                 assertFalse("vnfc has no edge uses", engine.tx().traversal().V(vnfc).both("uses").hasNext());
 350                 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
 351                 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
 352                 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V(gvnf).both("over-uses").hasNext());
 353                 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V(vnfc).both("over-uses").hasNext());
 354                 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(vnfc).both().count().next());
 355                 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(gvnf).both().count().next());
 356
 357         }
 358
 359         @Test
 360         public void deleteEdgeWithValidLabelWhenMultipleExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
 361
 362                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 363
 364                 engine.startTransaction();
 365
 366                 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf", "aai-uri", "/network/generic-vnfs/generic-vnf/myvnf");
 367                 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
 368                 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "uses");
 369                 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "re-uses");
 370                 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "over-uses");
 371
 372                 Introspector relData = loader.introspectorFromName("relationship-data");
 373                 relData.setValue("relationship-key", "vnfc.vnfc-name");
 374                 relData.setValue("relationship-value", "a-name");
 375                 Introspector relationship = loader.introspectorFromName("relationship");
 376                 relationship.setValue("related-to", "vnfc");
 377                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 378                 relationship.setValue("relationship-data",relData);
 379                 relationship.setValue("relationship-label", "re-uses");
 380
 381                 assertTrue(localDbser.deleteEdge(relationship, gvnf));
 382                 assertTrue("generic-vnf has edge uses", engine.tx().traversal().V(gvnf).both("uses").hasNext());
 383                 assertTrue("vnfc has edge uses", engine.tx().traversal().V(vnfc).both("uses").hasNext());
 384                 assertFalse("generic-vnf has no edge re-uses", engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
 385                 assertFalse("vnfc has no edge re-uses", engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
 386                 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V(gvnf).both("over-uses").hasNext());
 387                 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V(vnfc).both("over-uses").hasNext());
 388                 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(vnfc).both().count().next());
 389                 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(gvnf).both().count().next());
 390
 391         }
 392
 393         @Test
 394         public void deleteEdgeWithValidInvalidLabelWhenMultipleExistsTest() throws AAIException, UnsupportedEncodingException, 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", "/network/generic-vnfs/generic-vnf/myvnf");
 401                 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
 402                 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "uses");
 403                 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "re-uses");
 404                 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "over-uses");
 405
 406                 Introspector relData = loader.introspectorFromName("relationship-data");
 407                 relData.setValue("relationship-key", "vnfc.vnfc-name");
 408                 relData.setValue("relationship-value", "a-name");
 409                 Introspector relationship = loader.introspectorFromName("relationship");
 410                 relationship.setValue("related-to", "vnfc");
 411                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 412                 relationship.setValue("relationship-data",relData);
 413                 relationship.setValue("relationship-label", "NA");
 414
 415                 thrown.expect(AAIException.class);
 416                 thrown.expectMessage("No rule found");
 417                 thrown.expectMessage("node type: generic-vnf, node type: vnfc, label: NA, type: COUSIN");
 418                 localDbser.deleteEdge(relationship, gvnf);
 419         }
 420
 421         @Test
 422         public void serializeToDbWithLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
 423
 424                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 425
 426                 engine.startTransaction();
 427
 428                 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
 429
 430                 Introspector relationship = loader.introspectorFromName("relationship");
 431                 relationship.setValue("related-to", "vnfc");
 432                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 433                 relationship.setValue("relationship-label", "re-uses");
 434                 Introspector relationshipList = loader.introspectorFromName("relationship-list");
 435                 relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
 436
 437                 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
 438                 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
 439                 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
 440                 gvnfObj.setValue("vnf-id", "myvnf");
 441
 442                 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
 443
 444                 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 445
 446                 assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
 447                 assertTrue("vertex with vnfc-name a-name exists", engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
 448                 assertFalse("generic-vnf has no edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
 449                 assertFalse("vnfc has no edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
 450                 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
 451                 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
 452                 assertFalse("generic-vnf has no edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
 453                 assertFalse("vnfc has no edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
 454                 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
 455                 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
 456
 457         }
 458
 459         @Test
 460         public void serializeToDbWithoutLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
 461
 462                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 463
 464                 engine.startTransaction();
 465
 466                 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
 467
 468                 Introspector relationship = loader.introspectorFromName("relationship");
 469                 relationship.setValue("related-to", "vnfc");
 470                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 471
 472                 Introspector relationshipList = loader.introspectorFromName("relationship-list");
 473                 relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
 474
 475                 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
 476                 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
 477                 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
 478                 gvnfObj.setValue("vnf-id", "myvnf");
 479
 480                 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
 481
 482                 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 483
 484                 assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
 485                 assertTrue("vertex with vnfc-name a-name exists", engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
 486                 assertTrue("generic-vnf has edge uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
 487                 assertTrue("vnfc has edge uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
 488                 assertFalse("generic-vnf has no edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
 489                 assertFalse("vnfc has no edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
 490                 assertFalse("generic-vnf has no edge over-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
 491                 assertFalse("vnfc has no edge over-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
 492                 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
 493                 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
 494
 495         }
 496
 497         @Test
 498         public void serializeToDbWithInvalidLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
 499
 500                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 501
 502                 engine.startTransaction();
 503
 504                 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
 505
 506                 Introspector relationship = loader.introspectorFromName("relationship");
 507                 relationship.setValue("related-to", "vnfc");
 508                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 509                 relationship.setValue("relationship-label", "NA");
 510                 Introspector relationshipList = loader.introspectorFromName("relationship-list");
 511                 relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
 512
 513                 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
 514                 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
 515                 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
 516                 gvnfObj.setValue("vnf-id", "myvnf");
 517
 518                 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
 519
 520                 thrown.expect(AAIException.class);
 521                 thrown.expectMessage("No EdgeRule found for passed nodeTypes: generic-vnf, vnfc with label NA.");
 522                 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 523
 524         }
 525
 526         @Test
 527         public void serializeToDbWithLabelAndEdgeExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
 528
 529                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 530
 531                 engine.startTransaction();
 532                 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
 533
 534                 Introspector relationship;
 535                 Introspector relationshipList;
 536                 List<Object> relList = new ArrayList<>();
 537
 538                 // create generic-vnf
 539                 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
 540                 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
 541                 gvnfObj.setValue("vnf-id", "myvnf");
 542                 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
 543
 544                 // create relationship to vnfc
 545                 relationship = loader.introspectorFromName("relationship");
 546                 relationship.setValue("related-to", "vnfc");
 547                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 548                 relList.add(relationship.getUnderlyingObject());
 549                 relationshipList = loader.introspectorFromName("relationship-list");
 550                 relationshipList.setValue("relationship", relList);
 551                 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
 552
 553                 // add gvnf to graph
 554                 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 555
 556                 // add second relationship
 557                 relationship = loader.introspectorFromName("relationship");
 558                 relationship.setValue("related-to", "vnfc");
 559                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 560                 relationship.setValue("relationship-label", "re-uses");
 561                 relList.add(relationship.getUnderlyingObject());
 562                 relationshipList = loader.introspectorFromName("relationship-list");
 563                 relationshipList.setValue("relationship", relList);
 564                 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
 565
 566                 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 567
 568                 assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
 569                 assertTrue("vertex with vnfc-name a-name exists", engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
 570                 assertTrue("generic-vnf has  edge uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
 571                 assertTrue("vnfc has  edge uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
 572                 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
 573                 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
 574                 assertFalse("generic-vnf has no edge over-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
 575                 assertFalse("vnfc has no edge over-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
 576                 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
 577                 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
 578
 579         }
 580
 581         @Test
 582         public void serializeToDbWithLabelDroppingRelationshipTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
 583
 584                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 585
 586                 engine.startTransaction();
 587                 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
 588
 589
 590                 Introspector relationship;
 591                 Introspector relationshipList;
 592                 List<Object> relList = new ArrayList<>();
 593
 594                 // create generic-vnf
 595                 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
 596                 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
 597                 gvnfObj.setValue("vnf-id", "myvnf");
 598                 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
 599
 600                 // create relationship to vnfc
 601                 relationship = loader.introspectorFromName("relationship");
 602                 relationship.setValue("related-to", "vnfc");
 603                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 604                 relList.add(relationship.getUnderlyingObject());
 605                 // add second relationship
 606                 relationship = loader.introspectorFromName("relationship");
 607                 relationship.setValue("related-to", "vnfc");
 608                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 609                 relationship.setValue("relationship-label", "re-uses");
 610                 relList.add(relationship.getUnderlyingObject());
 611                 relationshipList = loader.introspectorFromName("relationship-list");
 612                 relationshipList.setValue("relationship", relList);
 613                 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
 614
 615                 // add gvnf to graph
 616                 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 617
 618                 // drop second relationship
 619                 relList.remove(1);
 620                 relationshipList = loader.introspectorFromName("relationship-list");
 621                 relationshipList.setValue("relationship", relList);
 622                 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
 623
 624                 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 625
 626                 assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
 627                 assertTrue("vertex with vnfc-name a-name exists", engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
 628                 assertTrue("generic-vnf has  edge uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
 629                 assertTrue("vnfc has  edge uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
 630                 assertFalse("generic-vnf no longer has edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
 631                 assertFalse("vnfc no longer has edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
 632                 assertFalse("generic-vnf has no edge over-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
 633                 assertFalse("vnfc has no edge over-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
 634                 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
 635                 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
 636
 637         }
 638
 639         private DBSerializer getDBSerializerWithSpecificEdgeRules()
 640                         throws NoSuchFieldException, AAIException, IllegalAccessException {
 641
 642
 643                 DBSerializer localDbser = new DBSerializer(version, engine, introspectorFactoryType, "AAI-TEST");
 644                 return localDbser;
 645         }
 646 }