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