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