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=========================================================
20 package org.onap.aai.rest;
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;
40 import javax.ws.rs.core.Response;
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;
52 @RunWith(value = Parameterized.class)
53 public class PrivateEdgeIntegrationTest extends AAISetup {
55 private static EELFLogger logger = EELFManager.getInstance().getLogger(PserverTest.class);
56 private HttpTestUtil httpTestUtil;
57 private Map<String, String> relationshipMap;
59 private String modelId;
60 private String modelVerId;
62 @Parameterized.Parameter(value = 0)
63 public QueryStyle queryStyle;
65 @Parameterized.Parameter(value = 1)
66 public SchemaVersion version;
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")}
85 public void setUpModelData() throws Exception {
86 httpTestUtil = new HttpTestUtil(QueryStyle.TRAVERSAL);
87 relationshipMap = new HashMap<>();
89 modelId = "test-model-" + UUID.randomUUID().toString();
90 modelVerId = "test-model-ver-" + UUID.randomUUID().toString();
92 createModel(modelId, modelVerId);
95 private void createModel(String modelId, String modelVerId) throws Exception {
96 Map<String, String> modelTemplateValues = new HashMap<>();
97 modelTemplateValues.put("model-invariant-id", modelId);
99 String modelPayload = PayloadUtil.getTemplatePayload("model.json", modelTemplateValues);
101 Response response = httpTestUtil.doPut("/aai/"+version.toString()+"/service-design-and-creation/models/model/" + modelId, modelPayload);
103 assertNotNull(response);
104 assertThat("Model was not successfully created", response.getStatus(), is(201));
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");
111 String modelVersionPayload = PayloadUtil.getTemplatePayload("model-ver.json", modelVersionTemplateValues);
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));
119 public void testPutGenericVnfWithModelInfoToMatchExistingModelAndCheckIfPrivateEdgeCreated() throws Exception {
121 Map<String, String> genericVnfHashMap = new HashMap<>();
122 String genericVnf = "test-generic-" + UUID.randomUUID().toString();
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);
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));
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);
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")));
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));
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));
155 public void testPutGenericVnfWithModelInfoToMatchExistingModelAndDoAnotherPutAndDontIncludeModelInfoAndPrivateEdgeShouldBeDeleted() throws Exception {
157 Map<String, String> genericVnfHashMap = new HashMap<>();
158 String genericVnf = "test-generic-" + UUID.randomUUID().toString();
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);
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));
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")));
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);
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 + "\"" +
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));
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));
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));
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));
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));
211 public void testPutGenericVnfWithModelInfoToMatchExistingModelAndCheckIfPrivateEdgeCreatedAndAlsoDoAnotherPutSameDataAndMakeSureEdgeIsStillThere() throws Exception {
212 Map<String, String> genericVnfHashMap = new HashMap<>();
213 String genericVnf = "test-generic-" + UUID.randomUUID().toString();
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);
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));
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")));
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);
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);
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));
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")));
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);
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));
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));
266 public void testPutGenericVnfWithModelThatDoesntExistAndCheckIfItReturnsNotFound() throws Exception {
267 Map<String, String> genericVnfHashMap = new HashMap<>();
268 String genericVnf = "test-generic-" + UUID.randomUUID().toString();
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);
275 Response response = httpTestUtil.doPut("/aai/"+version.toString()+"/network/generic-vnfs/generic-vnf/" + genericVnf, genericVnfPayload);
276 assertNotNull("Response returned null", response);
278 String body = response.getEntity().toString();
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"));
286 public void testPutGenericVnfWithModelMissingPartOfKeyReturnsBadRequest() throws Exception {
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" +
296 Response response = httpTestUtil.doPut("/aai/"+version.toString()+"/network/generic-vnfs/generic-vnf/" + genericVnf, genericVnfPayload);
297 assertNotNull("Response returned null", response);
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"));
306 public void testPutGenericVnfWithModelInfoToMatchExistingModelAndDeleteModelVerAndCheckIfPreventDeleteFailsWithBadRequest() throws Exception {
308 Map<String, String> genericVnfHashMap = new HashMap<>();
309 String genericVnf = "test-generic-" + UUID.randomUUID().toString();
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);
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));
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);
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]"));
337 public void testPutWithGenericVnfToExistingModelAndUpdateWithNewModelInfoAndEdgeToOldModelShouldBeDeletedAndNewEdgeToNewModelShouldBeCreated() throws Exception {
339 Map<String, String> genericVnfHashMap = new HashMap<>();
340 String genericVnf = "test-generic-" + UUID.randomUUID().toString();
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);
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));
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);
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")));
362 String resourceVersion = JsonPath.read(response.getEntity().toString(), "$.resource-version");
364 String newModelId = "test-model-" + UUID.randomUUID().toString();
365 String newModelVerId = "test-model-ver-" + UUID.randomUUID().toString();
367 createModel(newModelId, newModelVerId);
369 genericVnfHashMap.put("resource-version", resourceVersion);
370 genericVnfHashMap.put("model-invariant-id", newModelId);
371 genericVnfHashMap.put("model-version-id", newModelVerId);
373 String genericVnfPayloadWithResource = PayloadUtil.getTemplatePayload("generic-vnf-resource.json", genericVnfHashMap);
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));
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);
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");
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));
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));
402 public void testPutWithGenericVnfToExistingModelAndUpdateWithNewModelInfoThatDoesntExistAndCheckIfReturnsNotFoundAndOldEdgeShouldNotBeDeleted() throws Exception {
404 Map<String, String> genericVnfHashMap = new HashMap<>();
405 String genericVnf = "test-generic-" + UUID.randomUUID().toString();
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);
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));
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);
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")));
427 String resourceVersion = JsonPath.read(response.getEntity().toString(), "$.resource-version");
429 String newModelId = "test-model-" + UUID.randomUUID().toString();
430 String newModelVerId = "test-model-ver-" + UUID.randomUUID().toString();
432 genericVnfHashMap.put("resource-version", resourceVersion);
433 genericVnfHashMap.put("model-invariant-id", newModelId);
434 genericVnfHashMap.put("model-version-id", newModelVerId);
436 String genericVnfPayloadWithResource = PayloadUtil.getTemplatePayload("generic-vnf-resource.json", genericVnfHashMap);
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));
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);
451 public void testPutWithGenericVnfToExistingModelAndUpdateVnfWithModelMissingPartOfKeyAndUpdateShouldFailAndOldEdgeShouldStillExist() throws Exception {
453 Map<String, String> genericVnfHashMap = new HashMap<>();
454 String genericVnf = "test-generic-" + UUID.randomUUID().toString();
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);
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));
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);
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")));
476 String resourceVersion = JsonPath.read(response.getEntity().toString(), "$.resource-version");
478 String newModelId = "test-model-" + UUID.randomUUID().toString();
479 String newModelVerId = "test-model-ver-" + UUID.randomUUID().toString();
481 createModel(newModelId, newModelVerId);
483 genericVnfHashMap.put("resource-version", resourceVersion);
484 genericVnfHashMap.put("model-invariant-id", newModelId);
485 genericVnfHashMap.put("model-version-id", newModelVerId);
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" +
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"));
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);
509 public void testPutCustomerWithServiceInstanceThatHasModelVerThatExistsInDbAndDoGetOnCustomerAndCheckIfRelationshipIsNotThere() throws Exception {
511 Map<String, String> customerHashMap = new HashMap<>();
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);
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));
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);
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\"")));
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");
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" +
545 " \"related-to\": \"service-instance\",\n" +
546 " \"related-link\": \"" + url + "\"\n" +
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));
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\""));
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\""));
571 public void tearDown(){
573 JanusGraphTransaction transaction = AAIGraph.getInstance().getGraph().newTransaction();
574 boolean success = true;
578 GraphTraversalSource g = transaction.traversal();
580 g.V().has("source-of-truth", "JUNIT")
582 .forEach(v -> v.remove());
584 } catch(Exception ex){
586 logger.error("Unable to remove the vertexes", ex);
589 transaction.commit();
591 transaction.rollback();
592 fail("Unable to teardown the graph");