aai-core/src/test/java/org/onap/aai/rest/PrivateEdgeIntegrationTest.java

   1 /**
   2  * ============LICENSE_START=======================================================
   3  * org.onap.aai
   4  * ================================================================================
   5  * Copyright © 2017-2018 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.rest;
  22
  23 import static junit.framework.TestCase.fail;
  24
  25 import static org.hamcrest.CoreMatchers.containsString;
  26 import static org.hamcrest.CoreMatchers.not;
  27 import static org.hamcrest.MatcherAssert.assertThat;
  28 import static org.hamcrest.core.Is.is;
  29 import static org.junit.Assert.assertEquals;
  30 import static org.junit.Assert.assertNotEquals;
  31 import static org.junit.Assert.assertNotNull;
  32
  33 import org.slf4j.Logger;
  34 import org.slf4j.LoggerFactory;
  35 import com.jayway.jsonpath.JsonPath;
  36
  37 import java.util.*;
  38
  39 import javax.ws.rs.core.Response;
  40
  41 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
  42 import org.apache.tinkerpop.gremlin.structure.Edge;
  43 import org.janusgraph.core.JanusGraphTransaction;
  44 import org.junit.After;
  45 import org.junit.Before;
  46 import org.junit.Test;
  47 import org.junit.runner.RunWith;
  48 import org.junit.runners.Parameterized;
  49 import org.onap.aai.AAISetup;
  50 import org.onap.aai.HttpTestUtil;
  51 import org.onap.aai.PayloadUtil;
  52 import org.onap.aai.dbmap.AAIGraph;
  53 import org.onap.aai.serialization.engines.QueryStyle;
  54 import org.onap.aai.setup.SchemaVersion;
  55 import org.springframework.test.annotation.DirtiesContext;
  56
  57 @DirtiesContext(classMode = DirtiesContext.ClassMode.BEFORE_CLASS)
  58 @RunWith(value = Parameterized.class)
  59 public class PrivateEdgeIntegrationTest extends AAISetup {
  60
  61     private static Logger logger = LoggerFactory.getLogger(PserverTest.class);
  62     private HttpTestUtil httpTestUtil;
  63     private Map<String, String> relationshipMap;
  64
  65     private String modelId;
  66     private String modelVerId;
  67
  68     @Parameterized.Parameter(value = 0)
  69     public QueryStyle queryStyle;
  70
  71     @Parameterized.Parameter(value = 1)
  72     public SchemaVersion version;
  73
  74     @Parameterized.Parameters(name = "QueryStyle.{0} Version.{1}")
  75     public static Collection<Object[]> data() {
  76         return Arrays.asList(new Object[][] {{QueryStyle.TRAVERSAL, new SchemaVersion("v10")},
  77                 {QueryStyle.TRAVERSAL_URI, new SchemaVersion("v10")}, {QueryStyle.TRAVERSAL, new SchemaVersion("v11")},
  78                 {QueryStyle.TRAVERSAL_URI, new SchemaVersion("v11")}, {QueryStyle.TRAVERSAL, new SchemaVersion("v12")},
  79                 {QueryStyle.TRAVERSAL_URI, new SchemaVersion("v12")}, {QueryStyle.TRAVERSAL, new SchemaVersion("v13")},
  80                 {QueryStyle.TRAVERSAL_URI, new SchemaVersion("v13")}, {QueryStyle.TRAVERSAL, new SchemaVersion("v14")},
  81                 {QueryStyle.TRAVERSAL_URI, new SchemaVersion("v14")}});
  82     }
  83
  84     @Before
  85     public void setUpModelData() throws Exception {
  86         httpTestUtil = new HttpTestUtil(QueryStyle.TRAVERSAL);
  87         relationshipMap = new HashMap<>();
  88
  89         modelId = "test-model-" + UUID.randomUUID().toString();
  90         modelVerId = "test-model-ver-" + UUID.randomUUID().toString();
  91
  92         createModel(modelId, modelVerId);
  93     }
  94
  95     private void createModel(String modelId, String modelVerId) throws Exception {
  96         Map<String, String> modelTemplateValues = new HashMap<>();
  97         modelTemplateValues.put("model-invariant-id", modelId);
  98
  99         String modelPayload = PayloadUtil.getTemplatePayload("model.json", modelTemplateValues);
 100
 101         Response response = httpTestUtil.doPut(
 102                 "/aai/" + version.toString() + "/service-design-and-creation/models/model/" + modelId, modelPayload);
 103
 104         assertNotNull(response);
 105         assertThat("Model was not successfully created", response.getStatus(), is(201));
 106
 107         Map<String, String> modelVersionTemplateValues = new HashMap<>();
 108         modelVersionTemplateValues.put("model-version-id", modelVerId);
 109         modelVersionTemplateValues.put("model-name", "some-model");
 110         modelVersionTemplateValues.put("model-version", "testValue");
 111
 112         String modelVersionPayload = PayloadUtil.getTemplatePayload("model-ver.json", modelVersionTemplateValues);
 113
 114         response = httpTestUtil.doPut("/aai/" + version.toString() + "/service-design-and-creation/models/model/"
 115                 + modelId + "/model-vers/model-ver/" + modelVerId, modelVersionPayload);
 116         assertNotNull(response);
 117         assertThat("Model was not successfully created", response.getStatus(), is(201));
 118     }
 119
 120     @Test
 121     public void testPutGenericVnfWithModelInfoToMatchExistingModelAndCheckIfPrivateEdgeCreated() throws Exception {
 122
 123         Map<String, String> genericVnfHashMap = new HashMap<>();
 124         String genericVnf = "test-generic-" + UUID.randomUUID().toString();
 125
 126         genericVnfHashMap.put("vnf-id", genericVnf);
 127         genericVnfHashMap.put("model-invariant-id", modelId);
 128         genericVnfHashMap.put("model-version-id", modelVerId);
 129         String genericVnfPayload = PayloadUtil.getTemplatePayload("generic-vnf.json", genericVnfHashMap);
 130
 131         Response response = httpTestUtil.doPut(
 132                 "/aai/" + version.toString() + "/network/generic-vnfs/generic-vnf/" + genericVnf, genericVnfPayload);
 133         assertNotNull("Response returned null", response);
 134         assertThat("Check the generic vnf is created", response.getStatus(), is(201));
 135
 136         List<Edge> edges =
 137                 AAIGraph.getInstance().getGraph().newTransaction().traversal().E().has("private", true).toList();
 138         assertNotNull("List of edges should not be null", edges);
 139         assertThat(edges.size(), is(1));
 140         Edge oldEdge = edges.get(0);
 141         assertNotNull(oldEdge);
 142
 143         response = httpTestUtil.doGet("/aai/" + version.toString() + "/network/generic-vnfs/generic-vnf/" + genericVnf);
 144         assertNotNull("Response returned null", response);
 145         assertThat("Check the generic vnf is created", response.getStatus(), is(200));
 146         assertThat(response.getEntity().toString(), not(containsString("relationship-list")));
 147
 148         String resourceVersion = JsonPath.read(response.getEntity().toString(), "$.resource-version");
 149         response = httpTestUtil.doDelete(
 150                 "/aai/" + version.toString() + "/network/generic-vnfs/generic-vnf/" + genericVnf, resourceVersion);
 151         assertNotNull("Response returned null", response);
 152         assertThat("Check the generic vnf is deleted", response.getStatus(), is(204));
 153
 154         edges = AAIGraph.getInstance().getGraph().newTransaction().traversal().E().has("private", true).toList();
 155         assertNotNull("List of edges should not be null", edges);
 156         assertThat(edges.size(), is(0));
 157     }
 158
 159     @Test
 160     public void testPutGenericVnfWithModelInfoToMatchExistingModelAndDoAnotherPutAndDontIncludeModelInfoAndPrivateEdgeShouldBeDeleted()
 161             throws Exception {
 162
 163         Map<String, String> genericVnfHashMap = new HashMap<>();
 164         String genericVnf = "test-generic-" + UUID.randomUUID().toString();
 165
 166         genericVnfHashMap.put("vnf-id", genericVnf);
 167         genericVnfHashMap.put("model-invariant-id", modelId);
 168         genericVnfHashMap.put("model-version-id", modelVerId);
 169         String genericVnfPayload = PayloadUtil.getTemplatePayload("generic-vnf.json", genericVnfHashMap);
 170
 171         Response response = httpTestUtil.doPut(
 172                 "/aai/" + version.toString() + "/network/generic-vnfs/generic-vnf/" + genericVnf, genericVnfPayload);
 173         assertNotNull("Response returned null", response);
 174         assertThat("Check the generic vnf is created", response.getStatus(), is(201));
 175
 176         response = httpTestUtil.doGet("/aai/" + version.toString() + "/network/generic-vnfs/generic-vnf/" + genericVnf);
 177         assertNotNull("Response returned null", response);
 178         assertThat("Check the generic vnf is created", response.getStatus(), is(200));
 179         assertThat(response.getEntity().toString(), not(containsString("relationship-list")));
 180
 181         List<Edge> edges =
 182                 AAIGraph.getInstance().getGraph().newTransaction().traversal().E().has("private", true).toList();
 183         assertNotNull("List of edges should not be null", edges);
 184         assertThat(edges.size(), is(1));
 185         Edge oldEdge = edges.get(0);
 186         assertNotNull(oldEdge);
 187
 188         String resourceVersion = JsonPath.read(response.getEntity().toString(), "$.resource-version");
 189         String newGenericVnfPayload = "{\n" + "  \"vnf-id\": \"" + genericVnf + "\",\n"
 190                 + "  \"vnf-type\": \"someval\",\n" + "  \"vnf-name\": \"someval\"\n," + "  \"resource-version\": \""
 191                 + resourceVersion + "\"" + "}";
 192
 193         response = httpTestUtil.doPut("/aai/" + version.toString() + "/network/generic-vnfs/generic-vnf/" + genericVnf,
 194                 newGenericVnfPayload);
 195         assertNotNull("Response returned from second put is null", response);
 196         assertThat("Check the generic vnf is updated", response.getStatus(), is(200));
 197
 198         response = httpTestUtil.doGet("/aai/" + version.toString() + "/network/generic-vnfs/generic-vnf/" + genericVnf);
 199         assertNotNull("Response returned from second put is null", response);
 200         assertThat("Check the generic vnf is updated", response.getStatus(), is(200));
 201
 202         edges = AAIGraph.getInstance().getGraph().newTransaction().traversal().E().has("private", true).toList();
 203         assertNotNull("List of edges should not be null", edges);
 204         assertThat("Expected the edges to be zero since updated with no model info", edges.size(), is(0));
 205
 206         resourceVersion = JsonPath.read(response.getEntity().toString(), "$.resource-version");
 207         response = httpTestUtil.doDelete(
 208                 "/aai/" + version.toString() + "/network/generic-vnfs/generic-vnf/" + genericVnf, resourceVersion);
 209         assertNotNull("Response returned null", response);
 210         assertThat("Check the generic vnf is deleted", response.getStatus(), is(204));
 211
 212         edges = AAIGraph.getInstance().getGraph().newTransaction().traversal().E().has("private", true).toList();
 213         assertNotNull("List of edges should not be null", edges);
 214         assertThat(edges.size(), is(0));
 215     }
 216
 217     @Test
 218     public void testPutGenericVnfWithModelInfoToMatchExistingModelAndCheckIfPrivateEdgeCreatedAndAlsoDoAnotherPutSameDataAndMakeSureEdgeIsStillThere()
 219             throws Exception {
 220         Map<String, String> genericVnfHashMap = new HashMap<>();
 221         String genericVnf = "test-generic-" + UUID.randomUUID().toString();
 222
 223         genericVnfHashMap.put("vnf-id", genericVnf);
 224         genericVnfHashMap.put("model-invariant-id", modelId);
 225         genericVnfHashMap.put("model-version-id", modelVerId);
 226         String genericVnfPayload = PayloadUtil.getTemplatePayload("generic-vnf.json", genericVnfHashMap);
 227
 228         Response response = httpTestUtil.doPut(
 229                 "/aai/" + version.toString() + "/network/generic-vnfs/generic-vnf/" + genericVnf, genericVnfPayload);
 230         assertNotNull("Response returned null", response);
 231         assertThat("Check the generic vnf is created", response.getStatus(), is(201));
 232
 233         response = httpTestUtil.doGet("/aai/" + version.toString() + "/network/generic-vnfs/generic-vnf/" + genericVnf);
 234         assertNotNull("Response returned null", response);
 235         assertThat("Check the generic vnf is created", response.getStatus(), is(200));
 236         assertThat(response.getEntity().toString(), not(containsString("relationship-list")));
 237
 238         List<Edge> edges =
 239                 AAIGraph.getInstance().getGraph().newTransaction().traversal().E().has("private", true).toList();
 240         assertNotNull("List of edges should not be null", edges);
 241         assertThat(edges.size(), is(1));
 242         Edge oldEdge = edges.get(0);
 243         assertNotNull(oldEdge);
 244
 245         String resourceVersion = JsonPath.read(response.getEntity().toString(), "$.resource-version");
 246         genericVnfHashMap.put("resource-version", resourceVersion);
 247         String genericVnfPayloadWithResource =
 248                 PayloadUtil.getTemplatePayload("generic-vnf-resource.json", genericVnfHashMap);
 249
 250         response = httpTestUtil.doPut("/aai/" + version.toString() + "/network/generic-vnfs/generic-vnf/" + genericVnf,
 251                 genericVnfPayloadWithResource);
 252         assertNotNull("Response returned null", response);
 253         assertThat("Check the generic vnf is updated", response.getStatus(), is(200));
 254
 255         response = httpTestUtil.doGet("/aai/" + version.toString() + "/network/generic-vnfs/generic-vnf/" + genericVnf);
 256         assertNotNull("Response returned null", response);
 257         assertThat("Check the generic vnf is created", response.getStatus(), is(200));
 258         assertThat(response.getEntity().toString(), not(containsString("relationship-list")));
 259
 260         resourceVersion = JsonPath.read(response.getEntity().toString(), "$.resource-version");
 261         edges = AAIGraph.getInstance().getGraph().newTransaction().traversal().E().has("private", true).toList();
 262         assertNotNull("List of edges should not be null", edges);
 263         assertThat(edges.size(), is(1));
 264         Edge newEdge = edges.get(0);
 265         assertNotNull(newEdge);
 266         assertEquals(oldEdge, newEdge);
 267
 268         response = httpTestUtil.doDelete(
 269                 "/aai/" + version.toString() + "/network/generic-vnfs/generic-vnf/" + genericVnf, resourceVersion);
 270         assertNotNull("Response returned null", response);
 271         assertThat("Check the generic vnf is deleted", response.getStatus(), is(204));
 272
 273         edges = AAIGraph.getInstance().getGraph().newTransaction().traversal().E().has("private", true).toList();
 274         assertNotNull("List of edges should not be null", edges);
 275         assertThat(edges.size(), is(0));
 276     }
 277
 278     @Test
 279     public void testPutGenericVnfWithModelThatDoesntExistAndCheckIfItReturnsNotFound() throws Exception {
 280         Map<String, String> genericVnfHashMap = new HashMap<>();
 281         String genericVnf = "test-generic-" + UUID.randomUUID().toString();
 282
 283         genericVnfHashMap.put("vnf-id", genericVnf);
 284         genericVnfHashMap.put("model-invariant-id", "random-wrong-model");
 285         genericVnfHashMap.put("model-version-id", "random-wrong-model-ver");
 286         String genericVnfPayload = PayloadUtil.getTemplatePayload("generic-vnf.json", genericVnfHashMap);
 287
 288         Response response = httpTestUtil.doPut(
 289                 "/aai/" + version.toString() + "/network/generic-vnfs/generic-vnf/" + genericVnf, genericVnfPayload);
 290         assertNotNull("Response returned null", response);
 291
 292         String body = response.getEntity().toString();
 293
 294         logger.info("Response from the PUT request: " + body);
 295         assertThat("Check the generic vnf is created", response.getStatus(), is(404));
 296         assertThat(body, containsString("Node Not Found"));
 297     }
 298
 299     @Test
 300     public void testPutGenericVnfWithModelMissingPartOfKeyReturnsBadRequest() throws Exception {
 301
 302         String genericVnf = "test-generic-" + UUID.randomUUID().toString();
 303         String genericVnfPayload = "{\n" + "  \"vnf-id\": \"" + genericVnf + "\",\n" + "  \"vnf-type\": \"someval\",\n"
 304                 + "  \"vnf-name\": \"someval\",\n" + "  \"model-invariant-id\": \"some-model\"\n" + "}";
 305
 306         Response response = httpTestUtil.doPut(
 307                 "/aai/" + version.toString() + "/network/generic-vnfs/generic-vnf/" + genericVnf, genericVnfPayload);
 308         assertNotNull("Response returned null", response);
 309
 310         String body = response.getEntity().toString();
 311         logger.info("Response from the PUT request: " + body);
 312         assertThat("Check the generic vnf is created", response.getStatus(), is(400));
 313         assertThat(body, containsString("model-invariant-id requires model-version-id"));
 314     }
 315
 316     @Test
 317     public void testPutGenericVnfWithModelInfoToMatchExistingModelAndDeleteModelVerAndCheckIfPreventDeleteFailsWithBadRequest()
 318             throws Exception {
 319
 320         Map<String, String> genericVnfHashMap = new HashMap<>();
 321         String genericVnf = "test-generic-" + UUID.randomUUID().toString();
 322
 323         genericVnfHashMap.put("vnf-id", genericVnf);
 324         genericVnfHashMap.put("model-invariant-id", modelId);
 325         genericVnfHashMap.put("model-version-id", modelVerId);
 326         String genericVnfPayload = PayloadUtil.getTemplatePayload("generic-vnf.json", genericVnfHashMap);
 327
 328         Response response = httpTestUtil.doPut(
 329                 "/aai/" + version.toString() + "/network/generic-vnfs/generic-vnf/" + genericVnf, genericVnfPayload);
 330         assertNotNull("Response returned null", response);
 331         assertThat("Check the generic vnf is created", response.getStatus(), is(201));
 332
 333         List<Edge> edges =
 334                 AAIGraph.getInstance().getGraph().newTransaction().traversal().E().has("private", true).toList();
 335         assertNotNull("List of edges should not be null", edges);
 336         assertThat(edges.size(), is(1));
 337         Edge oldEdge = edges.get(0);
 338         assertNotNull(oldEdge);
 339
 340         response = httpTestUtil.doGet("/aai/" + version.toString() + "/service-design-and-creation/models/model/"
 341                 + modelId + "/model-vers/model-ver/" + modelVerId);
 342         assertNotNull(response);
 343         assertThat(response.getStatus(), is(200));
 344         String resourceVersion = JsonPath.read(response.getEntity().toString(), "$.resource-version");
 345         response = httpTestUtil.doDelete("/aai/" + version.toString() + "/service-design-and-creation/models/model/"
 346                 + modelId + "/model-vers/model-ver/" + modelVerId, resourceVersion);
 347         assertNotNull("Response returned null", response);
 348         assertThat("Check the generic vnf is deleted", response.getStatus(), is(400));
 349         assertThat(response.getEntity().toString(),
 350                 containsString(" Please clean up references from the following types [generic-vnf]"));
 351     }
 352
 353     @Test
 354     public void testPutWithGenericVnfToExistingModelAndUpdateWithNewModelInfoAndEdgeToOldModelShouldBeDeletedAndNewEdgeToNewModelShouldBeCreated()
 355             throws Exception {
 356
 357         Map<String, String> genericVnfHashMap = new HashMap<>();
 358         String genericVnf = "test-generic-" + UUID.randomUUID().toString();
 359
 360         genericVnfHashMap.put("vnf-id", genericVnf);
 361         genericVnfHashMap.put("model-invariant-id", modelId);
 362         genericVnfHashMap.put("model-version-id", modelVerId);
 363         String genericVnfPayload = PayloadUtil.getTemplatePayload("generic-vnf.json", genericVnfHashMap);
 364
 365         Response response = httpTestUtil.doPut(
 366                 "/aai/" + version.toString() + "/network/generic-vnfs/generic-vnf/" + genericVnf, genericVnfPayload);
 367         assertNotNull("Response returned null", response);
 368         assertThat("Check the generic vnf is created", response.getStatus(), is(201));
 369
 370         List<Edge> edges =
 371                 AAIGraph.getInstance().getGraph().newTransaction().traversal().E().has("private", true).toList();
 372         assertNotNull("List of edges should not be null", edges);
 373         assertThat(edges.size(), is(1));
 374         Edge oldEdge = edges.get(0);
 375         assertNotNull(oldEdge);
 376
 377         response = httpTestUtil.doGet("/aai/" + version.toString() + "/network/generic-vnfs/generic-vnf/" + genericVnf);
 378         assertNotNull("Response returned null", response);
 379         assertThat("Check the generic vnf is created", response.getStatus(), is(200));
 380         assertThat(response.getEntity().toString(), not(containsString("relationship-list")));
 381
 382         String resourceVersion = JsonPath.read(response.getEntity().toString(), "$.resource-version");
 383
 384         String newModelId = "test-model-" + UUID.randomUUID().toString();
 385         String newModelVerId = "test-model-ver-" + UUID.randomUUID().toString();
 386
 387         createModel(newModelId, newModelVerId);
 388
 389         genericVnfHashMap.put("resource-version", resourceVersion);
 390         genericVnfHashMap.put("model-invariant-id", newModelId);
 391         genericVnfHashMap.put("model-version-id", newModelVerId);
 392
 393         String genericVnfPayloadWithResource =
 394                 PayloadUtil.getTemplatePayload("generic-vnf-resource.json", genericVnfHashMap);
 395
 396         response = httpTestUtil.doPut("/aai/" + version.toString() + "/network/generic-vnfs/generic-vnf/" + genericVnf,
 397                 genericVnfPayloadWithResource);
 398         assertNotNull("Response returned null", response);
 399         assertThat("Check the generic vnf is successfully updated based on new model", response.getStatus(), is(200));
 400
 401         edges = AAIGraph.getInstance().getGraph().newTransaction().traversal().E().has("private", true).toList();
 402         assertNotNull("List of edges should not be null", edges);
 403         assertThat(edges.size(), is(1));
 404         Edge newEdge = edges.get(0);
 405         assertNotNull(newEdge);
 406         assertNotEquals(oldEdge, newEdge);
 407
 408         response = httpTestUtil.doGet("/aai/" + version.toString() + "/network/generic-vnfs/generic-vnf/" + genericVnf);
 409         assertNotNull("Response returned null", response);
 410         assertThat("Check the generic vnf is created", response.getStatus(), is(200));
 411         assertThat(response.getEntity().toString(), not(containsString("relationship-list")));
 412         resourceVersion = JsonPath.read(response.getEntity().toString(), "$.resource-version");
 413
 414         response = httpTestUtil.doDelete(
 415                 "/aai/" + version.toString() + "/network/generic-vnfs/generic-vnf/" + genericVnf, resourceVersion);
 416         assertNotNull("Response returned null", response);
 417         assertThat("Check the generic vnf is deleted", response.getStatus(), is(204));
 418
 419         edges = AAIGraph.getInstance().getGraph().newTransaction().traversal().E().has("private", true).toList();
 420         assertNotNull("List of edges should not be null", edges);
 421         assertThat(edges.size(), is(0));
 422     }
 423
 424     @Test
 425     public void testPutWithGenericVnfToExistingModelAndUpdateWithNewModelInfoThatDoesntExistAndCheckIfReturnsNotFoundAndOldEdgeShouldNotBeDeleted()
 426             throws Exception {
 427
 428         Map<String, String> genericVnfHashMap = new HashMap<>();
 429         String genericVnf = "test-generic-" + UUID.randomUUID().toString();
 430
 431         genericVnfHashMap.put("vnf-id", genericVnf);
 432         genericVnfHashMap.put("model-invariant-id", modelId);
 433         genericVnfHashMap.put("model-version-id", modelVerId);
 434         String genericVnfPayload = PayloadUtil.getTemplatePayload("generic-vnf.json", genericVnfHashMap);
 435
 436         Response response = httpTestUtil.doPut(
 437                 "/aai/" + version.toString() + "/network/generic-vnfs/generic-vnf/" + genericVnf, genericVnfPayload);
 438         assertNotNull("Response returned null", response);
 439         assertThat("Check the generic vnf is created", response.getStatus(), is(201));
 440
 441         List<Edge> edges =
 442                 AAIGraph.getInstance().getGraph().newTransaction().traversal().E().has("private", true).toList();
 443         assertNotNull("List of edges should not be null", edges);
 444         assertThat(edges.size(), is(1));
 445         Edge oldEdge = edges.get(0);
 446         assertNotNull(oldEdge);
 447
 448         response = httpTestUtil.doGet("/aai/" + version.toString() + "/network/generic-vnfs/generic-vnf/" + genericVnf);
 449         assertNotNull("Response returned null", response);
 450         assertThat("Check the generic vnf is created", response.getStatus(), is(200));
 451         assertThat(response.getEntity().toString(), not(containsString("relationship-list")));
 452
 453         String resourceVersion = JsonPath.read(response.getEntity().toString(), "$.resource-version");
 454
 455         String newModelId = "test-model-" + UUID.randomUUID().toString();
 456         String newModelVerId = "test-model-ver-" + UUID.randomUUID().toString();
 457
 458         genericVnfHashMap.put("resource-version", resourceVersion);
 459         genericVnfHashMap.put("model-invariant-id", newModelId);
 460         genericVnfHashMap.put("model-version-id", newModelVerId);
 461
 462         String genericVnfPayloadWithResource =
 463                 PayloadUtil.getTemplatePayload("generic-vnf-resource.json", genericVnfHashMap);
 464
 465         response = httpTestUtil.doPut("/aai/" + version.toString() + "/network/generic-vnfs/generic-vnf/" + genericVnf,
 466                 genericVnfPayloadWithResource);
 467         assertNotNull("Response returned null", response);
 468         assertThat("Check the generic vnf is failed due to missing model ver", response.getStatus(), is(404));
 469
 470         edges = AAIGraph.getInstance().getGraph().newTransaction().traversal().E().has("private", true).toList();
 471         assertNotNull("List of edges should not be null", edges);
 472         assertThat(edges.size(), is(1));
 473         Edge newEdge = edges.get(0);
 474         assertNotNull(newEdge);
 475         assertEquals(oldEdge, newEdge);
 476     }
 477
 478     @Test
 479     public void testPutWithGenericVnfToExistingModelAndUpdateVnfWithModelMissingPartOfKeyAndUpdateShouldFailAndOldEdgeShouldStillExist()
 480             throws Exception {
 481
 482         Map<String, String> genericVnfHashMap = new HashMap<>();
 483         String genericVnf = "test-generic-" + UUID.randomUUID().toString();
 484
 485         genericVnfHashMap.put("vnf-id", genericVnf);
 486         genericVnfHashMap.put("model-invariant-id", modelId);
 487         genericVnfHashMap.put("model-version-id", modelVerId);
 488         String genericVnfPayload = PayloadUtil.getTemplatePayload("generic-vnf.json", genericVnfHashMap);
 489
 490         Response response = httpTestUtil.doPut(
 491                 "/aai/" + version.toString() + "/network/generic-vnfs/generic-vnf/" + genericVnf, genericVnfPayload);
 492         assertNotNull("Response returned null", response);
 493         assertThat("Check the generic vnf is created", response.getStatus(), is(201));
 494
 495         List<Edge> edges =
 496                 AAIGraph.getInstance().getGraph().newTransaction().traversal().E().has("private", true).toList();
 497         assertNotNull("List of edges should not be null", edges);
 498         assertThat(edges.size(), is(1));
 499         Edge oldEdge = edges.get(0);
 500         assertNotNull(oldEdge);
 501
 502         response = httpTestUtil.doGet("/aai/" + version.toString() + "/network/generic-vnfs/generic-vnf/" + genericVnf);
 503         assertNotNull("Response returned null", response);
 504         assertThat("Check the generic vnf is created", response.getStatus(), is(200));
 505         assertThat(response.getEntity().toString(), not(containsString("relationship-list")));
 506
 507         String resourceVersion = JsonPath.read(response.getEntity().toString(), "$.resource-version");
 508
 509         String newModelId = "test-model-" + UUID.randomUUID().toString();
 510         String newModelVerId = "test-model-ver-" + UUID.randomUUID().toString();
 511
 512         createModel(newModelId, newModelVerId);
 513
 514         genericVnfHashMap.put("resource-version", resourceVersion);
 515         genericVnfHashMap.put("model-invariant-id", newModelId);
 516         genericVnfHashMap.put("model-version-id", newModelVerId);
 517
 518         String genericVnfPayloadWithResource = "{\n" + "  \"vnf-id\": \"" + genericVnf + "\",\n"
 519                 + "  \"vnf-type\": \"someval\",\n" + "  \"vnf-name\": \"someval\",\n" + "  \"model-invariant-id\": \""
 520                 + newModelId + "\",\n" + "  \"resource-version\": \"${resource-version}\"\n" + "}";
 521
 522         response = httpTestUtil.doPut("/aai/" + version.toString() + "/network/generic-vnfs/generic-vnf/" + genericVnf,
 523                 genericVnfPayloadWithResource);
 524         assertNotNull("Response returned null", response);
 525         assertThat("Check the generic vnf is failed due to missing model ver", response.getStatus(), is(400));
 526         assertThat(response.getEntity().toString(), containsString("model-invariant-id requires model-version-id"));
 527
 528         edges = AAIGraph.getInstance().getGraph().newTransaction().traversal().E().has("private", true).toList();
 529         assertNotNull("List of edges should not be null", edges);
 530         assertThat(edges.size(), is(1));
 531         Edge newEdge = edges.get(0);
 532         assertNotNull(newEdge);
 533         assertEquals(oldEdge, newEdge);
 534     }
 535
 536     @Test
 537     public void testPutCustomerWithServiceInstanceThatHasModelVerThatExistsInDbAndDoGetOnCustomerAndCheckIfRelationshipIsNotThere()
 538             throws Exception {
 539
 540         Map<String, String> customerHashMap = new HashMap<>();
 541
 542         customerHashMap.put("global-customer-id", "test-customer-" + UUID.randomUUID().toString());
 543         customerHashMap.put("subscription-type", "test-subtype-" + UUID.randomUUID().toString());
 544         customerHashMap.put("service-instance-id", "test-tenant-" + UUID.randomUUID().toString());
 545         customerHashMap.put("model-invariant-id", modelId);
 546         customerHashMap.put("model-version-id", modelVerId);
 547
 548         String customer = PayloadUtil.getTemplatePayload("customer.json", customerHashMap);
 549         Response response = httpTestUtil.doPut("/aai/" + version.toString() + "/business/customers/customer/"
 550                 + customerHashMap.get("global-customer-id"), customer);
 551         assertNotNull("Response returned null", response);
 552         assertThat("Check the cloud region is created with link to generic vnf", response.getStatus(), is(201));
 553
 554         List<Edge> edges =
 555                 AAIGraph.getInstance().getGraph().newTransaction().traversal().E().has("private", true).toList();
 556         assertNotNull("List of edges should not be null", edges);
 557         assertThat(edges.size(), is(1));
 558         Edge oldEdge = edges.get(0);
 559         assertNotNull(oldEdge);
 560
 561         response = httpTestUtil.doGet("/aai/" + version.toString() + "/business/customers/customer/"
 562                 + customerHashMap.get("global-customer-id"));
 563         assertNotNull("Response returned null", response);
 564         assertThat("Check the customer is returned", response.getStatus(), is(200));
 565         assertThat(response.getEntity().toString(), not(containsString("\"related-to\":\"model-ver\"")));
 566
 567         String url = "/aai/" + version + "/business/customers/customer/" + customerHashMap.get("global-customer-id")
 568                 + "/service-subscriptions/service-subscription/" + customerHashMap.get("subscription-type")
 569                 + "/service-instances/service-instance/" + customerHashMap.get("service-instance-id");
 570
 571         String genericVnf = "vnf-" + UUID.randomUUID().toString();
 572         String genericVnfPayload = "{\n" + "  \"vnf-id\": \"" + genericVnf + "\",\n" + "  \"vnf-type\": \"someval\",\n"
 573                 + "  \"vnf-name\": \"someval\",\n" + "  \"relationship-list\": {\n" + "    \"relationship\": [\n"
 574                 + "      {\n" + "        \"related-to\": \"service-instance\",\n" + "        \"related-link\": \"" + url
 575                 + "\"\n" + "      }\n" + "    ]\n" + "  }\n" + "}\n";
 576
 577         response = httpTestUtil.doPut("/aai/" + version.toString() + "/network/generic-vnfs/generic-vnf/" + genericVnf,
 578                 genericVnfPayload);
 579         assertNotNull("Response returned null", response);
 580         assertThat("Check the customer is returned", response.getStatus(), is(201));
 581
 582         response = httpTestUtil.doGet("/aai/" + version.toString() + "/network/generic-vnfs/generic-vnf/" + genericVnf);
 583         assertNotNull("Response returned null", response);
 584         assertThat("Check the customer is returned", response.getStatus(), is(200));
 585         assertThat(response.getEntity().toString(), containsString("\"related-to\":\"service-instance\""));
 586
 587         response = httpTestUtil.doGet("/aai/" + version.toString() + "/business/customers/customer/"
 588                 + customerHashMap.get("global-customer-id"));
 589         assertNotNull("Response returned null", response);
 590         assertThat("Check the customer is returned", response.getStatus(), is(200));
 591         assertThat(response.getEntity().toString(), not(containsString("\"related-to\":\"model-ver\"")));
 592         assertThat(response.getEntity().toString(), containsString("\"related-to\":\"generic-vnf\""));
 593
 594     }
 595
 596     @After
 597     public void tearDown() {
 598
 599         JanusGraphTransaction transaction = AAIGraph.getInstance().getGraph().newTransaction();
 600         boolean success = true;
 601
 602         try {
 603
 604             GraphTraversalSource g = transaction.traversal();
 605
 606             g.V().has("source-of-truth", "JUNIT").toList().forEach(v -> v.remove());
 607
 608         } catch (Exception ex) {
 609             success = false;
 610             logger.error("Unable to remove the vertexes", ex);
 611         } finally {
 612             if (success) {
 613                 transaction.commit();
 614             } else {
 615                 transaction.rollback();
 616                 fail("Unable to teardown the graph");
 617             }
 618         }
 619
 620     }
 621 }