2 * ============LICENSE_START=======================================================
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
21 package org.onap.aai.rest;
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;
32 import org.slf4j.Logger;
33 import org.slf4j.LoggerFactory;
34 import com.jayway.jsonpath.JsonPath;
38 import javax.ws.rs.core.Response;
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;
55 @RunWith(value = Parameterized.class)
56 public class PrivateEdgeIntegrationTest extends AAISetup {
58 private static Logger logger = LoggerFactory.getLogger(PserverTest.class);
59 private HttpTestUtil httpTestUtil;
60 private Map<String, String> relationshipMap;
62 private String modelId;
63 private String modelVerId;
65 @Parameterized.Parameter(value = 0)
66 public QueryStyle queryStyle;
68 @Parameterized.Parameter(value = 1)
69 public SchemaVersion version;
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")}});
82 public void setUpModelData() throws Exception {
83 httpTestUtil = new HttpTestUtil(QueryStyle.TRAVERSAL);
84 relationshipMap = new HashMap<>();
86 modelId = "test-model-" + UUID.randomUUID().toString();
87 modelVerId = "test-model-ver-" + UUID.randomUUID().toString();
89 createModel(modelId, modelVerId);
92 private void createModel(String modelId, String modelVerId) throws Exception {
93 Map<String, String> modelTemplateValues = new HashMap<>();
94 modelTemplateValues.put("model-invariant-id", modelId);
96 String modelPayload = PayloadUtil.getTemplatePayload("model.json", modelTemplateValues);
98 Response response = httpTestUtil.doPut(
99 "/aai/" + version.toString() + "/service-design-and-creation/models/model/" + modelId, modelPayload);
101 assertNotNull(response);
102 assertThat("Model was not successfully created", response.getStatus(), is(201));
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");
109 String modelVersionPayload = PayloadUtil.getTemplatePayload("model-ver.json", modelVersionTemplateValues);
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));
118 public void testPutGenericVnfWithModelInfoToMatchExistingModelAndCheckIfPrivateEdgeCreated() throws Exception {
120 Map<String, String> genericVnfHashMap = new HashMap<>();
121 String genericVnf = "test-generic-" + UUID.randomUUID().toString();
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);
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));
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);
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")));
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));
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));
157 public void testPutGenericVnfWithModelInfoToMatchExistingModelAndDoAnotherPutAndDontIncludeModelInfoAndPrivateEdgeShouldBeDeleted()
160 Map<String, String> genericVnfHashMap = new HashMap<>();
161 String genericVnf = "test-generic-" + UUID.randomUUID().toString();
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);
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));
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")));
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);
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 + "\"" + "}";
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));
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));
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));
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));
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));
215 public void testPutGenericVnfWithModelInfoToMatchExistingModelAndCheckIfPrivateEdgeCreatedAndAlsoDoAnotherPutSameDataAndMakeSureEdgeIsStillThere()
217 Map<String, String> genericVnfHashMap = new HashMap<>();
218 String genericVnf = "test-generic-" + UUID.randomUUID().toString();
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);
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));
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")));
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);
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);
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));
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")));
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);
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));
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));
276 public void testPutGenericVnfWithModelThatDoesntExistAndCheckIfItReturnsNotFound() throws Exception {
277 Map<String, String> genericVnfHashMap = new HashMap<>();
278 String genericVnf = "test-generic-" + UUID.randomUUID().toString();
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);
285 Response response = httpTestUtil.doPut(
286 "/aai/" + version.toString() + "/network/generic-vnfs/generic-vnf/" + genericVnf, genericVnfPayload);
287 assertNotNull("Response returned null", response);
289 String body = response.getEntity().toString();
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"));
297 public void testPutGenericVnfWithModelMissingPartOfKeyReturnsBadRequest() throws Exception {
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" + "}";
303 Response response = httpTestUtil.doPut(
304 "/aai/" + version.toString() + "/network/generic-vnfs/generic-vnf/" + genericVnf, genericVnfPayload);
305 assertNotNull("Response returned null", response);
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"));
314 public void testPutGenericVnfWithModelInfoToMatchExistingModelAndDeleteModelVerAndCheckIfPreventDeleteFailsWithBadRequest()
317 Map<String, String> genericVnfHashMap = new HashMap<>();
318 String genericVnf = "test-generic-" + UUID.randomUUID().toString();
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);
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));
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);
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]"));
351 public void testPutWithGenericVnfToExistingModelAndUpdateWithNewModelInfoAndEdgeToOldModelShouldBeDeletedAndNewEdgeToNewModelShouldBeCreated()
354 Map<String, String> genericVnfHashMap = new HashMap<>();
355 String genericVnf = "test-generic-" + UUID.randomUUID().toString();
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);
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));
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);
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")));
379 String resourceVersion = JsonPath.read(response.getEntity().toString(), "$.resource-version");
381 String newModelId = "test-model-" + UUID.randomUUID().toString();
382 String newModelVerId = "test-model-ver-" + UUID.randomUUID().toString();
384 createModel(newModelId, newModelVerId);
386 genericVnfHashMap.put("resource-version", resourceVersion);
387 genericVnfHashMap.put("model-invariant-id", newModelId);
388 genericVnfHashMap.put("model-version-id", newModelVerId);
390 String genericVnfPayloadWithResource =
391 PayloadUtil.getTemplatePayload("generic-vnf-resource.json", genericVnfHashMap);
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));
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);
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");
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));
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));
422 public void testPutWithGenericVnfToExistingModelAndUpdateWithNewModelInfoThatDoesntExistAndCheckIfReturnsNotFoundAndOldEdgeShouldNotBeDeleted()
425 Map<String, String> genericVnfHashMap = new HashMap<>();
426 String genericVnf = "test-generic-" + UUID.randomUUID().toString();
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);
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));
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);
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")));
450 String resourceVersion = JsonPath.read(response.getEntity().toString(), "$.resource-version");
452 String newModelId = "test-model-" + UUID.randomUUID().toString();
453 String newModelVerId = "test-model-ver-" + UUID.randomUUID().toString();
455 genericVnfHashMap.put("resource-version", resourceVersion);
456 genericVnfHashMap.put("model-invariant-id", newModelId);
457 genericVnfHashMap.put("model-version-id", newModelVerId);
459 String genericVnfPayloadWithResource =
460 PayloadUtil.getTemplatePayload("generic-vnf-resource.json", genericVnfHashMap);
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));
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);
476 public void testPutWithGenericVnfToExistingModelAndUpdateVnfWithModelMissingPartOfKeyAndUpdateShouldFailAndOldEdgeShouldStillExist()
479 Map<String, String> genericVnfHashMap = new HashMap<>();
480 String genericVnf = "test-generic-" + UUID.randomUUID().toString();
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);
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));
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);
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")));
504 String resourceVersion = JsonPath.read(response.getEntity().toString(), "$.resource-version");
506 String newModelId = "test-model-" + UUID.randomUUID().toString();
507 String newModelVerId = "test-model-ver-" + UUID.randomUUID().toString();
509 createModel(newModelId, newModelVerId);
511 genericVnfHashMap.put("resource-version", resourceVersion);
512 genericVnfHashMap.put("model-invariant-id", newModelId);
513 genericVnfHashMap.put("model-version-id", newModelVerId);
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" + "}";
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"));
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);
534 public void testPutCustomerWithServiceInstanceThatHasModelVerThatExistsInDbAndDoGetOnCustomerAndCheckIfRelationshipIsNotThere()
537 Map<String, String> customerHashMap = new HashMap<>();
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);
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));
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);
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\"")));
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");
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";
574 response = httpTestUtil.doPut("/aai/" + version.toString() + "/network/generic-vnfs/generic-vnf/" + genericVnf,
576 assertNotNull("Response returned null", response);
577 assertThat("Check the customer is returned", response.getStatus(), is(201));
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\""));
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\""));
594 public void tearDown() {
596 JanusGraphTransaction transaction = AAIGraph.getInstance().getGraph().newTransaction();
597 boolean success = true;
601 GraphTraversalSource g = transaction.traversal();
603 g.V().has("source-of-truth", "JUNIT").toList().forEach(v -> v.remove());
605 } catch (Exception ex) {
607 logger.error("Unable to remove the vertexes", ex);
610 transaction.commit();
612 transaction.rollback();
613 fail("Unable to teardown the graph");