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