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