2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017 - 2019 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.vid.job.impl;
23 import static java.util.stream.Collectors.counting;
24 import static java.util.stream.Collectors.groupingBy;
25 import static java.util.stream.Collectors.joining;
26 import static net.javacrumbs.jsonunit.JsonAssert.assertJsonEquals;
27 import static net.javacrumbs.jsonunit.JsonMatchers.jsonEquals;
28 import static net.javacrumbs.jsonunit.JsonMatchers.jsonNodePresent;
29 import static net.javacrumbs.jsonunit.JsonMatchers.jsonPartEquals;
30 import static net.javacrumbs.jsonunit.JsonMatchers.jsonPartMatches;
31 import static net.javacrumbs.jsonunit.core.Option.IGNORING_ARRAY_ORDER;
32 import static org.hamcrest.CoreMatchers.equalTo;
33 import static org.hamcrest.CoreMatchers.is;
34 import static org.hamcrest.CoreMatchers.notNullValue;
35 import static org.hamcrest.CoreMatchers.nullValue;
36 import static org.hamcrest.MatcherAssert.assertThat;
37 import static org.hamcrest.Matchers.hasProperty;
38 import static org.hamcrest.Matchers.hasSize;
39 import static org.hamcrest.core.Every.everyItem;
40 import static org.mockito.ArgumentMatchers.any;
41 import static org.mockito.ArgumentMatchers.argThat;
42 import static org.mockito.ArgumentMatchers.endsWith;
43 import static org.mockito.ArgumentMatchers.eq;
44 import static org.mockito.ArgumentMatchers.isNull;
45 import static org.mockito.Mockito.reset;
46 import static org.mockito.Mockito.times;
47 import static org.mockito.Mockito.verify;
48 import static org.mockito.Mockito.when;
49 import static org.onap.vid.job.Job.JobStatus.COMPLETED;
50 import static org.onap.vid.job.Job.JobStatus.COMPLETED_WITH_ERRORS;
51 import static org.onap.vid.job.Job.JobStatus.COMPLETED_WITH_NO_ACTION;
52 import static org.onap.vid.job.Job.JobStatus.FAILED;
53 import static org.onap.vid.job.Job.JobStatus.IN_PROGRESS;
54 import static org.onap.vid.job.Job.JobStatus.PAUSE;
55 import static org.onap.vid.job.Job.JobStatus.PENDING;
56 import static org.onap.vid.job.Job.JobStatus.PENDING_RESOURCE;
57 import static org.onap.vid.job.Job.JobStatus.RESOURCE_IN_PROGRESS;
58 import static org.onap.vid.job.Job.JobStatus.STOPPED;
59 import static org.onap.vid.job.impl.JobSchedulerInitializer.WORKERS_TOPICS;
60 import static org.onap.vid.model.JobAuditStatus.SourceStatus.VID;
61 import static org.onap.vid.testUtils.TestUtils.readJsonResourceFileAsObject;
62 import static org.testng.Assert.assertNull;
63 import static org.testng.AssertJUnit.assertEquals;
64 import static org.testng.AssertJUnit.assertFalse;
65 import static org.testng.AssertJUnit.assertTrue;
67 import com.fasterxml.jackson.databind.JsonNode;
68 import com.google.common.collect.ImmutableList;
69 import com.google.common.collect.ImmutableMap;
70 import java.lang.reflect.Method;
71 import java.util.Collection;
72 import java.util.Collections;
73 import java.util.List;
75 import java.util.Optional;
76 import java.util.Stack;
77 import java.util.UUID;
78 import java.util.function.BiConsumer;
79 import java.util.function.Supplier;
80 import java.util.stream.Collectors;
81 import java.util.stream.IntStream;
82 import java.util.stream.Stream;
83 import javax.inject.Inject;
84 import javax.ws.rs.ProcessingException;
85 import org.apache.commons.lang3.StringUtils;
86 import org.apache.commons.lang3.mutable.MutableInt;
87 import org.jetbrains.annotations.NotNull;
88 import org.mockito.ArgumentCaptor;
89 import org.mockito.Mockito;
90 import org.mockito.hamcrest.MockitoHamcrest;
91 import org.onap.portalsdk.core.service.DataAccessService;
92 import org.onap.portalsdk.core.util.SystemProperties;
93 import org.onap.vid.asdc.AsdcCatalogException;
94 import org.onap.vid.changeManagement.RequestDetailsWrapper;
95 import org.onap.vid.config.DataSourceConfig;
96 import org.onap.vid.config.JobCommandsConfigWithMockedMso;
97 import org.onap.vid.config.MockedAaiClientAndFeatureManagerConfig;
98 import org.onap.vid.job.Job;
99 import org.onap.vid.job.Job.JobStatus;
100 import org.onap.vid.job.JobType;
101 import org.onap.vid.job.JobsBrokerService;
102 import org.onap.vid.job.command.CommandUtils;
103 import org.onap.vid.job.command.InternalState;
104 import org.onap.vid.model.Action;
105 import org.onap.vid.model.JobAuditStatus;
106 import org.onap.vid.model.NameCounter;
107 import org.onap.vid.model.RequestReferencesContainer;
108 import org.onap.vid.model.ServiceInfo;
109 import org.onap.vid.model.ServiceModel;
110 import org.onap.vid.model.serviceInstantiation.BaseResource;
111 import org.onap.vid.model.serviceInstantiation.InstanceGroup;
112 import org.onap.vid.model.serviceInstantiation.ServiceInstantiation;
113 import org.onap.vid.mso.RestMsoImplementation;
114 import org.onap.vid.mso.RestObject;
115 import org.onap.vid.mso.model.RequestReferences;
116 import org.onap.vid.mso.rest.AsyncRequestStatus;
117 import org.onap.vid.mso.rest.AsyncRequestStatusList;
118 import org.onap.vid.properties.Features;
119 import org.onap.vid.services.AsyncInstantiationBaseTest;
120 import org.onap.vid.services.AsyncInstantiationBusinessLogic;
121 import org.onap.vid.services.AuditService;
122 import org.onap.vid.services.InstantiationTemplatesService;
123 import org.onap.vid.services.VersionService;
124 import org.onap.vid.testUtils.TestUtils;
125 import org.onap.vid.utils.DaoUtils;
126 import org.springframework.http.HttpMethod;
127 import org.springframework.test.context.ContextConfiguration;
128 import org.testng.annotations.BeforeClass;
129 import org.testng.annotations.BeforeMethod;
130 import org.testng.annotations.DataProvider;
131 import org.testng.annotations.Test;
132 import org.togglz.core.manager.FeatureManager;
134 //it's more like integration test than UT
135 //But it's very hard to test in API test so I use UT
136 @ContextConfiguration(classes = {DataSourceConfig.class, SystemProperties.class, MockedAaiClientAndFeatureManagerConfig.class, JobCommandsConfigWithMockedMso.class})
137 public class AsyncInstantiationIntegrationTest extends AsyncInstantiationBaseTest {
139 private static final String FAILED_STR = "FAILED";
140 private static final String COMPLETE_STR = "COMPLETE";
141 private static final String IN_PROGRESS_STR = "IN_PROGRESS";
142 private static final String REQUESTED = "REQUESTED";
143 private static final String PENDING_MANUAL_TASK = "PENDING_MANUAL_TASK";
144 public static final String RAW_DATA_FROM_MSO = "RAW DATA FROM MSO";
145 private static String USER_ID = "123";
146 public static String REQUEST_ID = UUID.randomUUID().toString();
147 public static String SERVICE_INSTANCE_ID = UUID.randomUUID().toString();
150 private VersionService versionService;
153 private JobsBrokerService jobsBrokerService;
156 private JobWorker jobWorker;
159 private FeatureManager featureManager;
162 private AsyncInstantiationBusinessLogic asyncInstantiationBL;
165 private AuditService auditService;
168 private RestMsoImplementation restMso;
171 private DataAccessService dataAccessService;
174 private CommandUtils commandUtils;
177 private InstantiationTemplatesService instantiationTemplates;
180 void initServicesInfoService() {
181 createInstanceParamsMaps();
182 when(versionService.retrieveBuildNumber()).thenReturn("fakeBuild");
187 dataAccessService.deleteDomainObjects(ServiceInfo.class, "1=1", DaoUtils.getPropsMap());
188 dataAccessService.deleteDomainObjects(JobDaoImpl.class, "1=1", DaoUtils.getPropsMap());
189 dataAccessService.deleteDomainObjects(NameCounter.class, "1=1", DaoUtils.getPropsMap());
194 Mockito.reset(restMso);
195 Mockito.reset(aaiClient);
196 Mockito.reset(commandUtils);
197 mockAaiClientAnyNameFree();
199 when(featureManager.isActive(Features.FLAG_ASYNC_ALACARTE_VNF)).thenReturn(true);
200 when(featureManager.isActive(Features.FLAG_ASYNC_ALACARTE_VFMODULE)).thenReturn(true);
201 when(featureManager.isActive(Features.FLAG_2006_VFMODULE_TAKES_TENANT_AND_REGION_FROM_VNF)).thenReturn(true);
205 public void whenPushNewBulk_thenAllServicesAreInPending() {
208 List<ServiceInfo> serviceInfoList = asyncInstantiationBL.getAllServicesInfo();
209 assertThat( serviceInfoList, everyItem(hasProperty("jobStatus", is(PENDING))));
212 private List<UUID> pushMacroBulk() {
213 ServiceInstantiation serviceInstantiation = generateMockMacroServiceInstantiationPayload(false,
214 createVnfList(instanceParamsMapWithoutParams, Collections.EMPTY_LIST, true),
215 3, true,PROJECT_NAME, true);
216 return asyncInstantiationBL.pushBulkJob(serviceInstantiation, USER_ID);
219 private UUID pushALaCarteWithVnf() {
220 ServiceInstantiation serviceInstantiation = generateALaCarteWithVnfsServiceInstantiationPayload();
221 List<UUID> uuids = asyncInstantiationBL.pushBulkJob(serviceInstantiation, USER_ID);
222 assertThat(uuids, hasSize(1));
226 private UUID pushALaCarteUpdateWithGroups() {
227 ServiceInstantiation serviceInstantiation = generateALaCarteUpdateWith1ExistingGroup2NewGroupsPayload();
228 List<UUID> uuids = asyncInstantiationBL.pushBulkJob(serviceInstantiation, USER_ID);
229 assertThat(uuids, hasSize(1));
233 public static RestObject<RequestReferencesContainer> createResponse(int statusCode) {
234 return createResponse(statusCode, SERVICE_INSTANCE_ID, REQUEST_ID);
237 public static RestObject<RequestReferencesContainer> createResponseRandomIds(int statusCode) {
238 return createResponse(statusCode, UUID.randomUUID().toString(), UUID.randomUUID().toString());
241 public static RestObject<RequestReferencesContainer> createResponse(int statusCode, String instanceId, String requestId) {
242 RequestReferences requestReferences = new RequestReferences();
243 requestReferences.setRequestId(requestId);
244 requestReferences.setInstanceId(instanceId);
245 RestObject<RequestReferencesContainer> restObject = new RestObject<>();
246 restObject.set(new RequestReferencesContainer(requestReferences));
247 restObject.setStatusCode(statusCode);
248 restObject.setRaw(RAW_DATA_FROM_MSO);
252 ImmutableList<String> statusesToStrings(JobStatus... jobStatuses) {
253 return Stream.of(jobStatuses).map(
254 Enum::toString).collect(ImmutableList.toImmutableList());
258 Make sure service state is in progress once request has sent to MSO
259 Make sure service state is in progress once request has sent to MSO and MSO status is in_progress
260 Make sure service state is Failed once we got from MSO failure state, and that job's are not collected any more.
261 Make sure service state is Completed successfully once we got from MSO complete, and that next job is peeked.
262 Once a service in the bulk is failed, other services moved to Stopped, and no other jobs from the bulk are peeked.
265 public void testStatusesOfMacroServiceInBulkDuringBulkLifeCycle() {
267 final String SERVICE_REQUEST_ID = UUID.randomUUID().toString();
268 final String SERVICE_INSTANCE_ID = UUID.randomUUID().toString();
269 final String SERVICE2_REQUEST_ID = UUID.randomUUID().toString();
270 final String SERVICE2_INSTANCE_ID = UUID.randomUUID().toString();
272 when(restMso.restCall(eq(HttpMethod.POST), eq(RequestReferencesContainer.class), any(), any(), eq(Optional.empty())))
273 .thenReturn(createResponse(200, SERVICE_INSTANCE_ID, SERVICE_REQUEST_ID));
275 ImmutableList<ImmutableList<String>> expectedStatusesForVid = ImmutableList.of(
276 statusesToStrings(PENDING, IN_PROGRESS, COMPLETED),
277 statusesToStrings(PENDING, IN_PROGRESS, FAILED),
278 statusesToStrings(PENDING, STOPPED)
281 ImmutableList<ImmutableList<String>> expectedStatusesForMso = ImmutableList.of(
282 ImmutableList.of(REQUESTED, IN_PROGRESS_STR, "not a state", FAILED_STR ,COMPLETE_STR),
283 ImmutableList.of(REQUESTED, FAILED_STR),
287 List<UUID> uuids = pushMacroBulk();
288 UUID firstJobUuid = uuids.get(0);
289 UUID secondJobUuid = uuids.get(1);
290 //assert that when get ProcessingException from restMso, status remain the same
291 when(restMso.GetForObject(endsWith(SERVICE_REQUEST_ID), eq(AsyncRequestStatus.class))).thenThrow(new ProcessingException("fake message"));
292 processJobsCountTimesAndAssertStatus(firstJobUuid, 10, IN_PROGRESS, PENDING);
294 //assert that when get IN_PROGRESS status from restMso, status remain IN_PROGRESS
295 when(restMso.GetForObject(endsWith(SERVICE_REQUEST_ID), eq(AsyncRequestStatus.class))).thenReturn(asyncRequestStatusResponseAsRestObject(IN_PROGRESS_STR));
296 processJobsCountTimesAndAssertStatus(firstJobUuid, 10, IN_PROGRESS, PENDING);
298 //assert that when get unrecognized status from restMso, status remain IN_PROGRESS
299 when(restMso.GetForObject(endsWith(SERVICE_REQUEST_ID), eq(AsyncRequestStatus.class))).thenReturn(asyncRequestStatusResponseAsRestObject("not a state"));
300 processJobsCountTimesAndAssertStatus(firstJobUuid, 10, IN_PROGRESS, PENDING);
302 //assert that when get non 200 status code during IN_PROGRESS, status remain IN_PROGRESS
303 when(restMso.GetForObject(endsWith(SERVICE_REQUEST_ID), eq(AsyncRequestStatus.class))).thenReturn(asyncRequestStatusResponseAsRestObject(COMPLETE_STR, 404));
304 processJobsCountTimesAndAssertStatus(firstJobUuid, 10, IN_PROGRESS, PENDING);
306 //when get job COMPLETE from MSO, service status become COMPLETED
307 when(restMso.GetForObject(endsWith(SERVICE_REQUEST_ID), eq(AsyncRequestStatus.class))).thenReturn(asyncRequestStatusResponseAsRestObject(COMPLETE_STR));
308 pullJobProcessAndPushBack(JobStatus.IN_PROGRESS, COMPLETED);
309 List<ServiceInfo> serviceInfoList = listServicesAndAssertStatus(COMPLETED, PENDING, firstJobUuid);
312 //for use later in the test
313 Map<UUID, JobStatus> expectedJobStatusMap = serviceInfoList.stream().collect(
314 Collectors.toMap(ServiceInfo::getJobId, x-> PENDING));
315 expectedJobStatusMap.put(firstJobUuid, COMPLETED);
317 //when handling another PENDING job, statuses are : COMPLETED, IN_PROGRESS, PENDING
318 when(restMso.restCall(eq(HttpMethod.POST), eq(RequestReferencesContainer.class), any(), any(), eq(Optional.empty())))
319 .thenReturn(createResponse(200, SERVICE2_INSTANCE_ID, SERVICE2_REQUEST_ID));
320 when(restMso.GetForObject(endsWith(SERVICE2_REQUEST_ID), eq(AsyncRequestStatus.class))).thenReturn(asyncRequestStatusResponseAsRestObject(IN_PROGRESS_STR));
321 processJobsCountTimes(10);
323 expectedJobStatusMap.put(secondJobUuid, JobStatus.IN_PROGRESS);
324 listServicesAndAssertStatus(expectedJobStatusMap);
327 //when get FAILED status from MSO statuses are : COMPLETED, FAILED, STOPPED
328 when(restMso.GetForObject(any(), eq(AsyncRequestStatus.class))).thenReturn(asyncRequestStatusResponseAsRestObject(FAILED_STR));
329 pullJobProcessAndPushBack(JobStatus.IN_PROGRESS, JobStatus.FAILED);
330 expectedJobStatusMap.put(secondJobUuid, JobStatus.FAILED);
331 expectedJobStatusMap = expectedJobStatusMap.entrySet().stream().collect(Collectors.toMap(
332 e -> e.getKey(), e -> e.getValue() == PENDING ? JobStatus.STOPPED : e.getValue()
335 listServicesAndAssertStatus(expectedJobStatusMap);
336 IntStream.range(0, uuids.size()).forEach(i -> {
337 UUID uuid = uuids.get(i);
338 List<String> vidStatuses = auditService.getAuditStatuses(uuid, VID).stream().map(x -> x.getJobStatus()).collect(Collectors.toList());
339 assertThat(vidStatuses, is(expectedStatusesForVid.get(i)));
342 //assert no more jobs to pull
343 assertFalse(jobsBrokerService.pull(PENDING, randomUuid()).isPresent());
344 assertFalse(jobsBrokerService.pull(JobStatus.IN_PROGRESS, randomUuid()).isPresent());
349 public static Object[][] AlaCarteStatuses(Method test) {
350 return new Object[][]{
351 {COMPLETE_STR, JobStatus.COMPLETED},
352 {FAILED_STR, JobStatus.COMPLETED_WITH_ERRORS},
357 Make sure service state is in progress once request has sent to MSO
358 Make sure service state is watching until state changes to complemented
359 Make sure service state is watching until vnf state changes to completed
360 Make sure service state is Completed successfully once we got from MSO complete for the vnf job.
363 @Test(dataProvider = "AlaCarteStatuses")
364 public void testStatusesOfServiceDuringALaCarteLifeCycleIgnoringVfModules(String msoVnfStatus, JobStatus expectedServiceStatus) {
366 [v] + push alacarte with 1 vnf
367 [v] verify STATUS pending
368 [v] + pull+execute (should post to MSO)
369 [v] verify STATUS in progress
370 [v] + pull+execute (should GET completed from MSO)
371 [v] verify STATUS in progress; TYPE watching
372 [v] verify job#2 *new* VNF job STATUS creating
373 [v] + pull+execute job#2 (should post to MSO)
374 [v] verify job#2 STATUS resource in progress
375 [v] verify job#1 STATUS in progress
376 [v] + pull+execute job#2 (should GET completed from MSO)
377 [v] verify job#2 STATUS completed
378 [v] + pull+execute job#1
379 [v] verify job#1 STATUS completed
381 * not looking on audit (yet)
383 when(featureManager.isActive(Features.FLAG_ASYNC_ALACARTE_VFMODULE)).thenReturn(false); // this makes the test pass without mocking the vfModules
384 final String SERVICE_REQUEST_ID = UUID.randomUUID().toString();
385 final String SERVICE_INSTANCE_ID = UUID.randomUUID().toString();
386 final String VNF_REQUEST_ID = UUID.randomUUID().toString();
389 //push alacarte with 1 vnf, verify STATUS pending
390 UUID uuid = pushALaCarteWithVnf();
391 singleServicesAndAssertStatus(JobStatus.PENDING, uuid);
392 //mock mso to answer 200 of create service instance request, verify STATUS in progress
393 when(restMso.restCall(eq(HttpMethod.POST), eq(RequestReferencesContainer.class), any(), endsWith("serviceInstances"), any())).thenReturn(
394 createResponse(200, SERVICE_INSTANCE_ID, SERVICE_REQUEST_ID));
395 //mock mso to answer COMPLETE for service instance create, job status shall remain IN_PROGRESS and type shall be Watching
396 when(restMso.GetForObject(endsWith(SERVICE_REQUEST_ID), eq(AsyncRequestStatus.class))).
397 thenReturn(asyncRequestStatusResponseAsRestObject(COMPLETE_STR));
398 //mock mso to answer 200 of create vnf instance request, pull+execute vnf job, STATUS resource in progress
399 when(restMso.restCall(eq(HttpMethod.POST), eq(RequestReferencesContainer.class), any(), endsWith(SERVICE_INSTANCE_ID + "/vnfs"), any())).thenReturn(
400 createResponse(200, UUID.randomUUID().toString(), VNF_REQUEST_ID));
401 when(restMso.GetForObject(endsWith(VNF_REQUEST_ID), eq(AsyncRequestStatus.class))).thenReturn(
402 asyncRequestStatusResponseAsRestObject(msoVnfStatus));
404 processJobsCountTimesAndAssertStatus(uuid, 100, expectedServiceStatus);
405 verify(restMso, times(1)).restCall(eq(HttpMethod.POST), any(), any(), eq("/serviceInstantiation/v7/serviceInstances"), any());
406 verify(restMso, times(1)).restCall(eq(HttpMethod.POST), any(), any(), endsWith(SERVICE_INSTANCE_ID + "/vnfs"), any());
407 verify(restMso, times(2)).GetForObject(any(), any());
412 this test is almost duplication of testStatusesOfServiceDuringALaCarteLifeCycleIgnoringVfModules.
414 IgnoringVfModules test check the scenario while FLAG_ASYNC_ALACARTE_VFMODULE is off
415 WithVfModules test check the scenario while FLAG_ASYNC_ALACARTE_VFMODULE is on
417 We shall consider later to remove testStatusesOfServiceDuringALaCarteLifeCycleIgnoringVfModules
418 And union these tests to single one.
422 public void testALaCarteLifeCycle1Vnf2VfModules() {
425 String msoVnfStatus = COMPLETE_STR;
426 final String SERVICE_REQUEST_ID = UUID.randomUUID().toString();
427 final String SERVICE_INSTANCE_ID = UUID.randomUUID().toString();
428 final String VNF_REQUEST_ID = UUID.randomUUID().toString();
429 final String VNF_INSTANCE_ID = UUID.randomUUID().toString();
430 final String VG_REQUEST_ID = UUID.randomUUID().toString();
431 final String VG_INSTANCE_ID = UUID.randomUUID().toString();
432 final String VF_MODULE_REQUEST_ID = UUID.randomUUID().toString();
433 final String VF_MODULE_REQUEST_ID2 = UUID.randomUUID().toString();
436 //push alacarte with 1 vnf, verify STATUS pending
437 UUID uuid = pushALaCarteWithVnf();
438 singleServicesAndAssertStatus(JobStatus.PENDING, uuid);
440 /*---------- service -----------*/
442 //mock mso to answer 200 of create service instance request, verify STATUS in progress
443 when(restMso.restCall(eq(HttpMethod.POST), eq(RequestReferencesContainer.class), any(), endsWith("serviceInstances"), any())).thenReturn(
444 createResponse(200, SERVICE_INSTANCE_ID, SERVICE_REQUEST_ID));
446 //mock mso to answer COMPLETE for service instance create
447 when(restMso.GetForObject(endsWith(SERVICE_REQUEST_ID), eq(AsyncRequestStatus.class))).
448 thenReturn(asyncRequestStatusResponseAsRestObject(COMPLETE_STR));
450 /*---------- vnf -----------*/
452 //mock mso to answer 200 of create vnf instance request
453 when(restMso.restCall(eq(HttpMethod.POST), eq(RequestReferencesContainer.class), any(), endsWith(SERVICE_INSTANCE_ID + "/vnfs"), any())).thenReturn(
454 createResponse(200, VNF_INSTANCE_ID, VNF_REQUEST_ID));
456 //mock mso to answer msoVnfStatus (COMPLETE/FAILED) for vnf creation status,
457 when(restMso.GetForObject(endsWith(VNF_REQUEST_ID), eq(AsyncRequestStatus.class))).
458 thenReturn(asyncRequestStatusResponseAsRestObject(COMPLETE_STR));
461 when(commandUtils.isVfModuleBaseModule(eq(SERVICE_MODEL_VERSION_ID),
462 argThat(it -> it.getModelCustomizationId().equals(VF_MODULE_0_MODEL_CUSTOMIZATION_NAME)))).thenReturn(true);
463 when(commandUtils.isVfModuleBaseModule(eq(SERVICE_MODEL_VERSION_ID),
464 argThat(it -> it.getModelCustomizationId().equals(VF_MODULE_1_MODEL_CUSTOMIZATION_NAME)))).thenReturn(false);
466 /*---------- vf Module without volume group name (base) -----------*/
468 //mock mso to answer 200 of create vfModule instance request, pull+execute volumeGroup job, STATUS resource in progress
469 when(restMso.restCall(eq(HttpMethod.POST), eq(RequestReferencesContainer.class), any(), endsWith(SERVICE_INSTANCE_ID + "/vnfs/" + VNF_INSTANCE_ID + "/vfModules"), any())).thenReturn(
470 createResponse(200, UUID.randomUUID().toString(), VG_REQUEST_ID));
471 //mock mso to answer for vf module orchestration request
472 when(restMso.GetForObject(endsWith(VF_MODULE_REQUEST_ID), eq(AsyncRequestStatus.class))).thenReturn(
473 asyncRequestStatusResponseAsRestObject(COMPLETE_STR));
475 when(restMso.restCall(eq(HttpMethod.POST), eq(RequestReferencesContainer.class), any(), endsWith(SERVICE_INSTANCE_ID + "/vnfs/" + VNF_INSTANCE_ID + "/volumeGroups"), any())).thenReturn(
476 createResponse(200, VG_INSTANCE_ID, VG_REQUEST_ID));
477 //mock mso to answer for volume group orchestration request
478 when(restMso.GetForObject(endsWith(VG_REQUEST_ID), eq(AsyncRequestStatus.class))).thenReturn(
479 asyncRequestStatusResponseAsRestObject(msoVnfStatus));
481 /*---------- vfModule -----------*/
483 //mock mso to answer 200 of create vfModule instance request, pull+execute volumeGroup job, STATUS resource in progress
484 when(restMso.restCall(eq(HttpMethod.POST), eq(RequestReferencesContainer.class), any(), endsWith(SERVICE_INSTANCE_ID + "/vnfs/" + VNF_INSTANCE_ID + "/vfModules"), any())).thenReturn(
485 createResponse(200, UUID.randomUUID().toString(), VF_MODULE_REQUEST_ID2));
487 //mock mso to answer for vf module orchestration request
488 when(restMso.GetForObject(endsWith(VF_MODULE_REQUEST_ID2), eq(AsyncRequestStatus.class))).thenReturn(
489 asyncRequestStatusResponseAsRestObject(COMPLETE_STR));
491 processJobsCountTimesAndAssertStatus(uuid, 200, COMPLETED);
492 verify(restMso, times(1)).restCall(eq(HttpMethod.POST), any(), any(), eq("/serviceInstantiation/v7/serviceInstances"), any());
493 verify(restMso, times(1)).restCall(eq(HttpMethod.POST), any(), any(), endsWith(SERVICE_INSTANCE_ID + "/vnfs"), any());
494 verify(restMso, times(1)).restCall(eq(HttpMethod.POST), any(), any(), endsWith(SERVICE_INSTANCE_ID + "/vnfs/" + VNF_INSTANCE_ID + "/volumeGroups"), any());
495 verify(restMso, times(2)).restCall(eq(HttpMethod.POST), any(), any(), endsWith(SERVICE_INSTANCE_ID + "/vnfs/" + VNF_INSTANCE_ID + "/vfModules"), any());
496 verify(restMso, times(5)).GetForObject(any(), any());
500 public void testALaCarteLifeCycle2Networks() {
502 //Create Service with 2 networks, and make sure they created in sequence (and not in parallel)
503 //Config MSO to response 200 only to first network creation. And answer 500 for second one.
504 //Then MSO return in_progress some times (like 10 times), and then return COMPLETE.
505 //Only when MSO return COMPLETE for first network, config MSO to return 200 for second network creation
507 final String SERVICE_REQUEST_ID = UUID.randomUUID().toString();
508 final String SERVICE_INSTANCE_ID = UUID.randomUUID().toString();
509 final String NETWORK_REQUEST_ID1 = UUID.randomUUID().toString();
510 final String NETWORK_INSTANCE_ID1 = UUID.randomUUID().toString();
511 //TODO use them later for different networks
512 final String NETWORK_REQUEST_ID2 = UUID.randomUUID().toString();
513 final String NETWORK_INSTANCE_ID2 = UUID.randomUUID().toString();
516 NetworkDetails networkDetails1 = new NetworkDetails("LukaDoncic", "1");
517 NetworkDetails networkDetails2 = new NetworkDetails("KevinDurant", "2");
519 /*---------- service -----------*/
521 //mock mso to answer 200 of create service instance request, verify STATUS in progress
522 when(restMso.restCall(eq(HttpMethod.POST), eq(RequestReferencesContainer.class), any(), endsWith("serviceInstances"), any())).thenReturn(
523 createResponse(200, SERVICE_INSTANCE_ID, SERVICE_REQUEST_ID));
525 //mock mso to answer COMPLETE for service instance create
526 when(restMso.GetForObject(endsWith(SERVICE_REQUEST_ID), eq(AsyncRequestStatus.class))).
527 thenReturn(asyncRequestStatusResponseAsRestObject(COMPLETE_STR));
529 final MutableInt secondNetworkCode = new MutableInt(500);
530 final MutableInt inProgressCount = new MutableInt(0);
532 /*---------- network 1-----------*/
534 //mock mso to answer 200 of first create network instance request
535 when(restMso.restCall(eq(HttpMethod.POST), eq(RequestReferencesContainer.class),
536 MockitoHamcrest.argThat(jsonPartMatches("requestDetails.requestInfo.instanceName", equalTo(networkDetails1.name))) ,
537 endsWith(SERVICE_INSTANCE_ID + "/networks"), any())).thenReturn(
538 createResponse(200, NETWORK_INSTANCE_ID1, NETWORK_REQUEST_ID1));
540 //mock mso to answer IN_PROGRESS 10 times, and only then COMPLETE for first network
541 //Once COMPLETE, second network creation will return 200
542 when(restMso.GetForObject(endsWith(NETWORK_REQUEST_ID1), eq(AsyncRequestStatus.class))).
545 if (inProgressCount.getValue()<10) {
546 status = IN_PROGRESS_STR;
548 secondNetworkCode.setValue(200);
549 status = COMPLETE_STR;
551 inProgressCount.add(1);
552 return asyncRequestStatusResponseAsRestObject(status);
555 /*---------- network 2-----------*/
557 //mock MSO to return status code of secondNetworkCode (500 and 200 after first one COMPLETED)
558 when(restMso.restCall(eq(HttpMethod.POST), eq(RequestReferencesContainer.class),
559 MockitoHamcrest.argThat(jsonPartMatches("requestDetails.requestInfo.instanceName", equalTo(networkDetails2.name))) ,
560 endsWith(SERVICE_INSTANCE_ID + "/networks"), any())).thenAnswer(x->
561 createResponse(secondNetworkCode.intValue(), NETWORK_INSTANCE_ID2, NETWORK_REQUEST_ID2));
563 // when(restMso.restCall(eq(HttpMethod.POST), eq(RequestReferencesContainer.class), any() , endsWith(SERVICE_INSTANCE_ID + "/networks"), any())).thenReturn(
564 // createResponse(200, NETWORK_INSTANCE_ID1, NETWORK_REQUEST_ID1));
565 //mock mso to answer COMPLETE for network creation status,
567 when(restMso.GetForObject(endsWith(NETWORK_REQUEST_ID2), eq(AsyncRequestStatus.class))).
568 thenReturn(asyncRequestStatusResponseAsRestObject(COMPLETE_STR));
571 /*---------- Create request and process it -----------*/
572 //push alacarte with 2 networks, verify STATUS pending
573 when(featureManager.isActive(Features.FLAG_EXP_CREATE_RESOURCES_IN_PARALLEL)).thenReturn(false);
574 ServiceInstantiation serviceInstantiation = generateALaCarteWithNetworksPayload(ImmutableList.of(networkDetails1, networkDetails2));
575 UUID uuid = asyncInstantiationBL.pushBulkJob(serviceInstantiation, USER_ID).get(0);
576 singleServicesAndAssertStatus(JobStatus.PENDING, uuid);
578 processJobsCountTimesAndAssertStatus(uuid, 200, COMPLETED);
580 //validate the mso request id is the right one
581 List<ServiceInfo> serviceInfoList = asyncInstantiationBL.getAllServicesInfo();
582 ServiceInfo serviceInfo = serviceInfoList.get(0);
583 assertThat(serviceInfo.getMsoRequestId(), is(UUID.fromString(SERVICE_REQUEST_ID)));
585 /*---------- verify -----------*/
586 verify(restMso, times(1)).restCall(eq(HttpMethod.POST), any(), any(), eq("/serviceInstantiation/v7/serviceInstances"), any());
587 verify(restMso, times(2)).restCall(eq(HttpMethod.POST), any(), any(), endsWith(SERVICE_INSTANCE_ID + "/networks"), any());
589 verify(restMso, times(1)).GetForObject(endsWith(SERVICE_REQUEST_ID), any());
590 verify(restMso, times(11)).GetForObject(endsWith(NETWORK_REQUEST_ID1), any());
591 verify(restMso, times(1)).GetForObject(endsWith(NETWORK_REQUEST_ID2), any());
595 public void testBadAaiResponseForSearchNamesAndBackToNormal() {
596 when(aaiClient.isNodeTypeExistsByName(any(), any())).thenThrow(aaiNodeQueryBadResponseException());
597 when(restMso.restCall(eq(HttpMethod.POST), eq(RequestReferencesContainer.class), any(), any(), eq(Optional.empty()))).thenReturn(createResponse(200));
598 when(restMso.GetForObject(any(), eq(AsyncRequestStatus.class))).
599 thenReturn(asyncRequestStatusResponseAsRestObject(COMPLETE_STR));
601 List<UUID> uuids = pushMacroBulk();
602 processJobsCountTimesAndAssertStatus(uuids.get(0), 5, IN_PROGRESS, PENDING); //JOB shall become IN_PROGRESS but service info is still pending
604 //simulate AAI back to normal, AAI return name is free, and MSO return good response
605 Mockito.reset(aaiClient); // must forget the "thenThrow"
606 when(aaiClient.isNodeTypeExistsByName(any(), any())).thenReturn(false);
607 processJobsCountTimesAndAssertStatus(uuids.get(0), 30, COMPLETED, COMPLETED);
612 public void testAaiResponseNameUsedTillMaxRetries() {
613 when(aaiClient.isNodeTypeExistsByName(any(), any())).thenReturn(true);
614 //simulate MSO to return good result, for making sure we failed because of AAI error
615 when(restMso.restCall(eq(HttpMethod.POST), eq(RequestReferencesContainer.class), any(), any(), eq(Optional.empty()))).thenReturn(createResponse(200));
616 when(restMso.GetForObject(any(), eq(AsyncRequestStatus.class))).
617 thenReturn(asyncRequestStatusResponseAsRestObject(COMPLETE_STR));
619 asyncInstantiationBL.setMaxRetriesGettingFreeNameFromAai(10);
620 List<UUID> uuids = pushMacroBulk();
621 processJobsCountTimesAndAssertStatus(uuids.get(0), 20, FAILED, STOPPED);
624 private Job pullJobProcessAndPushBack(JobStatus topic, JobStatus expectedNextJobStatus) {
625 return pullJobProcessAndPushBack(topic, expectedNextJobStatus, true);
628 //return the pulled job (and not the pushed job)
629 private Job pullJobProcessAndPushBack(JobStatus topic, JobStatus expectedNextJobStatus, boolean pullingAssertion) {
630 Optional<Job> job = pullJob(topic, pullingAssertion);
632 Job nextJob = jobWorker.executeJobAndGetNext(job.get());
635 assertThat("next job not ok: " + nextJob.getData(), nextJob.getStatus(), is(expectedNextJobStatus));
637 if (pullingAssertion) {
638 //assert another pulling on same topic return no result (before push back)
639 assertFalse(jobsBrokerService.pull(topic, randomUuid()).isPresent());
643 jobsBrokerService.pushBack(nextJob); // push back to let retries - even if any assertion failure
645 assertThat(jobsBrokerService.peek(job.get().getUuid()).getStatus(), is(expectedNextJobStatus));
649 private void simplePullJobProcessAndPushBack(JobStatus topic) {
650 Optional<Job> optionalJob = jobsBrokerService.pull(topic, randomUuid());
651 optionalJob.ifPresent(job->{
652 Job nextJob = jobWorker.executeJobAndGetNext(job);
653 jobsBrokerService.pushBack(nextJob);
657 private Job pullJobProcessAndPushBackWithTypeAssertion(JobStatus topic, JobStatus expectedNextJobStatus,
658 JobType expectedNextJobType) {
659 Job job = pullJobProcessAndPushBack(topic, expectedNextJobStatus, false);
660 assertThat("job not ok: " + job.getData(), job.getType(), is(expectedNextJobType));
664 private Job pullJobProcessAndPushBackWithTypeAssertion(JobStatus topic, JobStatus expectedNextJobStatus,
665 JobType expectedNextJobType, Action actionPhase, InternalState internalState, int retries) {
666 return retryWithAssertionsLimit(retries, () -> {
667 Job job = pullJobProcessAndPushBackWithTypeAssertion(topic, expectedNextJobStatus, expectedNextJobType);
668 assertThat("job not ok: " + job.getData(), job.getData(), is(jsonPartEquals("actionPhase", actionPhase.name())));
669 if (internalState != null) {
670 assertThat("job not ok: " + job.getData(), job.getData(), is(jsonPartEquals("internalState", internalState.name())));
676 private Job retryWithAssertionsLimit(int retries, Supplier<Job> supplier) {
677 java.util.Stack<AssertionError> history = new Stack<>();
681 return supplier.get();
682 } catch (AssertionError assertionError) {
683 history.push(assertionError);
685 } while (history.size() < retries);
688 throw new AssertionError("No luck while all of these assertion errors: " + history.stream()
689 .map(Throwable::getMessage)
690 .map(s -> s.replace('\n', ' '))
691 .map(s -> s.replaceAll("\\s{2,}"," "))
693 .collect(joining("\n ", "\n ", "")), history.peek());
696 private Optional<Job> pullJob(JobStatus topic, boolean pullingAssertion) {
697 if (pullingAssertion) {
698 //assert pulling on inverse topic return no result
699 assertFalse(jobsBrokerService.pull(inverseTopic(topic), randomUuid()).isPresent());
702 Optional<Job> job = jobsBrokerService.pull(topic, randomUuid());
703 assertTrue("no job fetched", job.isPresent());
705 if (pullingAssertion) {
706 //assert another pulling on same topic return no result
707 assertFalse(jobsBrokerService.pull(topic, randomUuid()).isPresent());
713 private JobStatus inverseTopic(JobStatus topic) {
714 return topic==JobStatus.IN_PROGRESS ? PENDING : JobStatus.IN_PROGRESS;
719 public void whenPushNewBulk_andGetNoResponseFromMsoOnCreation_thenServiceMoveToFailedAndOtherToStopped() {
720 when(restMso.restCall(eq(HttpMethod.POST), eq(RequestReferencesContainer.class), any(), any(), eq(Optional.empty()))).thenReturn(createResponse(500));
721 //assert that when get ProcessingException from restMso, status remain the same
722 List<UUID> uuids = pushMacroBulk();
723 processJobsCountTimesAndAssertStatus(uuids.get(0), 30, JobStatus.FAILED, JobStatus.STOPPED);
727 public void whenMsoStatusIsPendingManualTask_ThenJobStatusIsPaused() {
728 when(restMso.restCall(eq(HttpMethod.POST), eq(RequestReferencesContainer.class), any(), any(), eq(Optional.empty()))).thenReturn(createResponse(200));
729 when(restMso.GetForObject(any(), eq(AsyncRequestStatus.class))).
730 thenReturn(asyncRequestStatusResponseAsRestObject(PENDING_MANUAL_TASK));
732 //assert that when get ProcessingException from restMso, status remain the same
733 List<UUID> uuids = pushMacroBulk();
734 processJobsCountTimesAndAssertStatus(uuids.get(0), 30, PAUSE, PENDING);
737 //the job get IN_PROGRESS response (simulate activate operation) and status changed to IN_PROGRESS
738 when(restMso.GetForObject(any(), eq(AsyncRequestStatus.class))).
739 thenReturn(asyncRequestStatusResponseAsRestObject(IN_PROGRESS_STR));
740 processJobsCountTimesAndAssertStatus(uuids.get(0), 30, IN_PROGRESS, PENDING);
742 //the job get COMPLETE response this job is copmpleted and then also other jobs
743 when(restMso.GetForObject(any(), eq(AsyncRequestStatus.class))).
744 thenReturn(asyncRequestStatusResponseAsRestObject(COMPLETE_STR));
745 processJobsCountTimesAndAssertStatus(uuids.get(0), 200, COMPLETED, COMPLETED);
747 ImmutableList<String> expectedStatusesForVid = statusesToStrings(PENDING, IN_PROGRESS, PAUSE, IN_PROGRESS, COMPLETED);
748 List<String> vidStatuses = auditService.getAuditStatuses(uuids.get(0), VID).stream().map(x -> x.getJobStatus()).collect(Collectors.toList());
749 assertThat(vidStatuses, is(expectedStatusesForVid));
752 private Job pushBulkPullPendingJobAndAssertJobStatus(JobStatus pulledJobStatus, JobStatus otherJobsStatus) {
754 return pullPendingJobAndAssertJobStatus(pulledJobStatus, otherJobsStatus);
757 private Job pullPendingJobAndAssertJobStatus(JobStatus pulledJobStatus, JobStatus otherJobsStatus) {
758 Job job = pullJobProcessAndPushBack(PENDING, pulledJobStatus, false);
759 listServicesAndAssertStatus(pulledJobStatus, otherJobsStatus, job.getUuid());
764 public void test2BulksLifeCyclesAreIndependent() {
766 final String SERVICE1_REQUEST_ID = UUID.randomUUID().toString();
767 final String SERVICE1_INSTANCE_ID = UUID.randomUUID().toString();
768 final String SERVICE2_REQUEST_ID = UUID.randomUUID().toString();
769 final String SERVICE2_INSTANCE_ID = UUID.randomUUID().toString();
770 final String SERVICE3_4_REQUEST_ID = UUID.randomUUID().toString();
771 final String SERVICE3_4_INSTANCE_ID = UUID.randomUUID().toString();
774 //create first bulk and make one job in progress
775 List<UUID> firstBulksIDs = pushMacroBulk();
776 when(restMso.restCall(eq(HttpMethod.POST), eq(RequestReferencesContainer.class), any(), any(), eq(Optional.empty())))
777 .thenReturn(createResponse(200, SERVICE1_INSTANCE_ID, SERVICE1_REQUEST_ID));
778 when(restMso.GetForObject(endsWith(SERVICE1_REQUEST_ID), eq(AsyncRequestStatus.class))).
779 thenReturn(asyncRequestStatusResponseAsRestObject(IN_PROGRESS_STR));
780 processJobsCountTimesAndAssertStatus(firstBulksIDs.get(0), 30, IN_PROGRESS, PENDING);
782 //create 2nd bulk, then when pulling first job the job become in_progress, other jobs (from 2 bulks) remain pending
783 when(restMso.restCall(eq(HttpMethod.POST), eq(RequestReferencesContainer.class), any(), any(), eq(Optional.empty())))
784 .thenReturn(createResponse(200, SERVICE2_INSTANCE_ID, SERVICE2_REQUEST_ID));
785 when(restMso.GetForObject(endsWith(SERVICE2_REQUEST_ID), eq(AsyncRequestStatus.class))).
786 thenReturn(asyncRequestStatusResponseAsRestObject(IN_PROGRESS_STR));
787 List<UUID> secondBulksIDs = pushMacroBulk();
788 processJobsCountTimes(30);
789 Map<JobStatus, Long> statusCount = getJobStatusesCount();
790 assertThat(statusCount.get(IN_PROGRESS), is(2L));
791 assertThat(statusCount.get(PENDING), is(4L));
793 //return failed to first job
794 //first bulk statuses shall be: FAILED, STOPPED, STOPPED
795 //second bulk statuses shall be: IN_PROGRESS, PENDING, PENDING
796 when(restMso.GetForObject(endsWith(SERVICE1_REQUEST_ID), eq(AsyncRequestStatus.class))).
797 thenReturn(asyncRequestStatusResponseAsRestObject(FAILED_STR));
798 processJobsCountTimes(30);
799 Map<UUID, List<ServiceInfo>> servicesByTemplateId =
800 asyncInstantiationBL.getAllServicesInfo()
801 .stream().collect(groupingBy(ServiceInfo::getTemplateId));
802 ServiceInfo failedJob = asyncInstantiationBL.getAllServicesInfo().stream().filter(x->x.getJobId().equals(firstBulksIDs.get(0))).findFirst().get();
803 assertServicesStatus(servicesByTemplateId.get(failedJob.getTemplateId()), JobStatus.FAILED, JobStatus.STOPPED, failedJob.getJobId());
804 ServiceInfo successJob = asyncInstantiationBL.getAllServicesInfo().stream().filter(x->x.getJobId().equals(secondBulksIDs.get(0))).findFirst().get();
805 assertServicesStatus(servicesByTemplateId.get(successJob.getTemplateId()), JobStatus.IN_PROGRESS, PENDING, successJob.getJobId());
807 //return completed to all other jobs
808 when(restMso.restCall(eq(HttpMethod.POST), eq(RequestReferencesContainer.class), any(), any(), eq(Optional.empty())))
809 .thenReturn(createResponse(200, SERVICE3_4_INSTANCE_ID, SERVICE3_4_REQUEST_ID));
810 when(restMso.GetForObject(endsWith(SERVICE2_REQUEST_ID), eq(AsyncRequestStatus.class))).
811 thenReturn(asyncRequestStatusResponseAsRestObject(COMPLETE_STR));
812 when(restMso.GetForObject(endsWith(SERVICE3_4_REQUEST_ID), eq(AsyncRequestStatus.class))).
813 thenReturn(asyncRequestStatusResponseAsRestObject(COMPLETE_STR));
815 processJobsCountTimes(30);
816 servicesByTemplateId = asyncInstantiationBL.getAllServicesInfo().stream().collect(groupingBy(ServiceInfo::getTemplateId));
817 assertServicesStatus(servicesByTemplateId.get(failedJob.getTemplateId()), JobStatus.FAILED, JobStatus.STOPPED, failedJob.getJobId());
818 assertServicesStatus(servicesByTemplateId.get(successJob.getTemplateId()), COMPLETED, COMPLETED, successJob.getJobId());
819 //assert no more PENDING jobs nor IN_PROGRESS jobs to pull
820 assertFalse(jobsBrokerService.pull(PENDING, randomUuid()).isPresent());
821 assertFalse(jobsBrokerService.pull(JobStatus.IN_PROGRESS, randomUuid()).isPresent());
824 protected Map<JobStatus, Long> getJobStatusesCount() {
825 return asyncInstantiationBL.getAllServicesInfo().stream().collect(groupingBy(ServiceInfo::getJobStatus, counting()));
829 public void deploy2NewGroupsToServiceWith1ExistingGroup() {
832 new feature: skip service (existing impl) and skip group (new impl)
833 service+group aren't touched, 2 groups ARE created
835 [v] success if all GROUPs success
837 Next test variation should:
838 [ ] error if all GROUPs error
839 [ ] completed with error if 1 GROUP error
842 [v] + service with 3 groups - 1 action=none, 2 action=create; service's action=none
843 [v] verify STATUS pending
844 [v] + pull+execute (should NOT post to MSO)
845 [v] verify STATUS in progress; TYPE watching
848 [v] + pull+execute job#1
849 [v] verify job#1 STATUS in progress; TYPE watching
851 [v] + pull+execute job#6 (should post to MSO)
852 [v] verify job#6 STATUS resource in progress
853 [v] + pull+execute job#1
854 [v] verify job#1 STATUS in progress; TYPE watching
855 [v] + pull+execute job#6 (should get from MSO)
856 [v] verify job#6 STATUS completed
857 [v] + pull+execute job#1
858 [v] verify job#1 STATUS in progress; TYPE watching
860 [v] + pull+execute job#7 (should post to MSO)
861 [v] verify job#7 STATUS resource in progress
862 [v] + pull+execute job#1
863 [v] verify job#1 STATUS in progress; TYPE watching
864 [v] + pull+execute job#7 (should get from MSO)
865 [v] verify job#7 STATUS completed
866 [v] + pull+execute job#1
867 [v] verify job#1 STATUS completed
871 final String GROUP1_REQUEST_ID = UUID.randomUUID().toString();
872 final String GROUP1_INSTANCE_ID = UUID.randomUUID().toString();
873 final String GROUP2_REQUEST_ID = UUID.randomUUID().toString();
874 final String GROUP2_INSTANCE_ID = UUID.randomUUID().toString();
877 final BiConsumer<Action, JobStatus> verify_Job1InProgress = (phase, nextJobStatus) -> {
878 pullJobProcessAndPushBackWithTypeAssertion(IN_PROGRESS, nextJobStatus, JobType.ALaCarteService, phase, InternalState.WATCHING, 2);
881 //service with 3 groups - 1 action=none, 2 action=create; service's action=none
882 UUID uuid = pushALaCarteUpdateWithGroups();
883 singleServicesAndAssertStatus(PENDING, uuid);
885 // take from pending, put in-progress -> 3 delete-child were born
886 pullJobProcessAndPushBackWithTypeAssertion(PENDING, IN_PROGRESS, JobType.ALaCarteService, Action.Create, InternalState.INITIAL, 1);
887 verifyQueueSizes(ImmutableMap.of(
891 // take job #1 from phase delete to phase create -> 3 create-child were born
892 verify_Job1InProgress.accept(Action.Create, IN_PROGRESS);
893 verifyQueueSizes(ImmutableMap.of(
894 IN_PROGRESS, 1, PENDING_RESOURCE, 3
898 when(restMso.restCall(eq(HttpMethod.POST), eq(RequestReferencesContainer.class), any(), endsWith("instanceGroups"), eq(Optional.empty())))
899 .thenReturn(createResponse(200, GROUP1_INSTANCE_ID, GROUP1_REQUEST_ID))
900 .thenReturn(createResponse(200, GROUP2_INSTANCE_ID, GROUP2_REQUEST_ID))
902 when(restMso.GetForObject(argThat(uri -> StringUtils.endsWithAny(uri, GROUP1_REQUEST_ID, GROUP2_REQUEST_ID)), eq(AsyncRequestStatus.class))).
903 thenReturn(asyncRequestStatusResponseAsRestObject(COMPLETE_STR));
905 // take first "none" child from creating to COMPLETED_WITH_NO_ACTION
906 // note there's no concrete mechanism that makes the first child be
907 // the "action=None" case, but that's what happens, and following lines
908 // relies on that fact.
909 pullJobProcessAndPushBackWithTypeAssertion(PENDING_RESOURCE, COMPLETED_WITH_NO_ACTION, JobType.InstanceGroup, Action.Create, null, 1);
911 // take each of next two children from creating to in-progress, then to completed
912 // verify job #1 is watching, and MSO is getting requests
913 Stream.of(1, 2).forEach(i -> {
914 verify_Job1InProgress.accept(Action.Create, IN_PROGRESS);
915 pullJobProcessAndPushBackWithTypeAssertion(PENDING_RESOURCE, RESOURCE_IN_PROGRESS, JobType.InstanceGroup, Action.Create, InternalState.IN_PROGRESS, 1);
916 verify(restMso, times(i)).restCall(any(), any(), any(), any(), any());
918 verify_Job1InProgress.accept(Action.Create, IN_PROGRESS);
919 pullJobProcessAndPushBackWithTypeAssertion(RESOURCE_IN_PROGRESS, COMPLETED, JobType.InstanceGroup, Action.Create, null, 3);
920 verify(restMso, times(i)).GetForObject(any(), any());
923 // job #1 is done as all children are done
924 verify_Job1InProgress.accept(Action.Create, COMPLETED);
925 verifyQueueSizes(ImmutableMap.of(COMPLETED, 3, COMPLETED_WITH_NO_ACTION, 1));
929 public static Object[][] createAndDeleteIntegrationTestDataProvider(Method test) {
930 return new Object[][]{
931 {"create and delete both bad http code", createResponse(400), createResponse(500), null, null, FAILED, 0},
932 {"create and delete success and status is success ", createResponseRandomIds(202), createResponseRandomIds(202),
933 asyncRequestStatusResponseAsRestObject(COMPLETE_STR), asyncRequestStatusResponseAsRestObject(COMPLETE_STR), COMPLETED, 2},
934 {"create and delete success, create status FAILED, delete status COMPLETED", createResponseRandomIds(202), createResponseRandomIds(202),
935 asyncRequestStatusResponseAsRestObject(FAILED_STR), asyncRequestStatusResponseAsRestObject(COMPLETE_STR), COMPLETED_WITH_ERRORS, 2},
936 {"create and delete success, create status FAILED, delete status FAILED", createResponseRandomIds(202), createResponseRandomIds(202),
937 asyncRequestStatusResponseAsRestObject(FAILED_STR), asyncRequestStatusResponseAsRestObject(FAILED_STR), FAILED, 2},
938 {"create success but delete failed and status is success ", createResponseRandomIds(202), createResponseRandomIds(400),
939 asyncRequestStatusResponseAsRestObject(COMPLETE_STR), null, COMPLETED_WITH_ERRORS, 1},
940 {"delete success but create failed and status is success ", createResponseRandomIds(400), createResponseRandomIds(202),
941 null, asyncRequestStatusResponseAsRestObject(COMPLETE_STR), COMPLETED_WITH_ERRORS, 1},
942 {"delete success but create failed and status of delete is FAILED ", createResponseRandomIds(400), createResponseRandomIds(202),
943 null, asyncRequestStatusResponseAsRestObject(FAILED_STR), FAILED, 1}
947 //this test is going along with AsyncInstantiationALaCarteApiTest.viewEditVnfGroup__verifyStatusAndAudit API test
948 //The API test has only the happy flow scenario, while this test also test additional MSO responses (mostly non happy)
949 @Test(dataProvider="createAndDeleteIntegrationTestDataProvider")
950 public void vnfGropingIntegrationTest(
952 RestObject<RequestReferencesContainer> createGroupResponse,
953 RestObject<RequestReferencesContainer> deleteGroupResponse,
954 RestObject<AsyncRequestStatus> createStatusResponse,
955 RestObject<AsyncRequestStatus> deleteStatusResponse,
956 JobStatus expectedJobStatus,
957 int getStatusCounter) {
959 UUID jobUUID = createAndDeleteIntegrationTest("/payload_jsons/VnfGroupCreate1Delete1None1Request.json",
960 "/serviceInstantiation/v7/instanceGroups",
962 "/serviceInstantiation/v7/instanceGroups/VNF_GROUP1_INSTANCE_ID",
964 createStatusResponse,
965 deleteStatusResponse,
969 ServiceInstantiation bulkForRetry = asyncInstantiationBL.getBulkForRetry(jobUUID);
970 InstanceGroup vnfGroupShouldBeDeleted = bulkForRetry.getVnfGroups().get("groupingservicefortest..ResourceInstanceGroup..0:001");
971 InstanceGroup vnfGroupShouldBeCreated = bulkForRetry.getVnfGroups().get("groupingservicefortest..ResourceInstanceGroup..0");
973 if (deleteStatusResponse == null || deleteStatusResponse.get().request.requestStatus.getRequestState().equals(FAILED_STR)) {
974 assertThat(vnfGroupShouldBeDeleted.getAction(), equalTo(Action.Delete));
975 assertErrorForResource(vnfGroupShouldBeDeleted, deleteGroupResponse, deleteStatusResponse);
978 if (createStatusResponse == null || createStatusResponse.get().request.requestStatus.getRequestState().equals(FAILED_STR)) {
979 assertThat(vnfGroupShouldBeCreated.getAction(), equalTo(Action.Create));
980 assertErrorForResource(vnfGroupShouldBeCreated, createGroupResponse, createStatusResponse);
984 //this test is going along with AsyncInstantiationALaCarteApiTest3.delete1Create1VnfFromService API test
985 //The API test has only the happy flow scenario, while this test also test additional MSO responses (mostly non happy)
986 @Test(dataProvider="createAndDeleteIntegrationTestDataProvider")
987 public void vnfsIntegrationTest(
989 RestObject<RequestReferencesContainer> createVnfResponse,
990 RestObject<RequestReferencesContainer> deleteVnfResponse,
991 RestObject<AsyncRequestStatus> createStatusResponse,
992 RestObject<AsyncRequestStatus> deleteStatusResponse,
993 JobStatus expectedJobStatus,
994 int getStatusCounter) {
996 createAndDeleteIntegrationTest("/payload_jsons/vnfDelete1Create1Request.json",
997 "/serviceInstantiation/v7/serviceInstances/f8791436-8d55-4fde-b4d5-72dd2cf13cfb/vnfs",
999 "/serviceInstantiation/v7/serviceInstances/f8791436-8d55-4fde-b4d5-72dd2cf13cfb/vnfs/VNF_INSTANCE_ID",
1001 createStatusResponse,
1002 deleteStatusResponse,
1007 @Test(dataProvider="createAndDeleteIntegrationTestDataProvider")
1008 public void vfModulesIntegrationTest(
1010 RestObject<RequestReferencesContainer> createVfModuleResponse,
1011 RestObject<RequestReferencesContainer> deleteVfModuleResponse,
1012 RestObject<AsyncRequestStatus> createStatusResponse,
1013 RestObject<AsyncRequestStatus> deleteStatusResponse,
1014 JobStatus expectedJobStatus,
1015 int getStatusCounter) {
1017 when(commandUtils.isVfModuleBaseModule(eq("6b528779-44a3-4472-bdff-9cd15ec93450"),
1018 argThat(it -> it.getModelCustomizationName().equals("2017488PasqualeVpe..PASQUALE_base_vPE_BV..module-0")))).thenReturn(true);
1019 when(commandUtils.isVfModuleBaseModule(eq("6b528779-44a3-4472-bdff-9cd15ec93450"),
1020 argThat(it -> it.getModelCustomizationName().equals("2017488PasqualeVpe..PASQUALE_vRE_BV..module-1")))).thenReturn(false);
1022 createAndDeleteIntegrationTest("/payload_jsons/vfModuleDelete1Create1None1Request.json",
1023 "/serviceInstantiation/v7/serviceInstances/f8791436-8d55-4fde-b4d5-72dd2cf13cfb/vnfs/VNF_INSTANCE_ID/vfModules",
1024 createVfModuleResponse,
1025 "/serviceInstantiation/v7/serviceInstances/f8791436-8d55-4fde-b4d5-72dd2cf13cfb/vnfs/VNF_INSTANCE_ID/vfModules/VF_MODULE_INSTANCE_ID",
1026 deleteVfModuleResponse,
1027 createStatusResponse,
1028 deleteStatusResponse,
1034 public static Object[][] pauseInstantiation(Method test) {
1035 return new Object[][]{
1041 @Test (dataProvider = "pauseInstantiation")
1042 public void viewEdit_existingVnfCreate3VfModulesPauseAfterTheSecond(boolean flag, int expectedNumberOfInvocation) {
1043 RestObject<RequestReferencesContainer> createVfModuleResponse = createResponseRandomIds(202);
1044 RestObject<AsyncRequestStatus> createStatusResponse = asyncRequestStatusResponseAsRestObject(COMPLETE_STR);
1045 JobStatus expectedJobStatus = COMPLETED;
1047 when(featureManager.isActive(Features.FLAG_2006_PAUSE_VFMODULE_INSTANTIATION_CREATION)).thenReturn(flag);
1049 when(commandUtils.isVfModuleBaseModule(eq("6b528779-44a3-4472-bdff-9cd15ec93450"),
1050 argThat(it -> it.getModelCustomizationName().equals("2017488PasqualeVpe..PASQUALE_base_vPE_BV..module-0")))).thenReturn(true);
1052 UUID jobUUID = asyncInstantiationBL.pushBulkJob(
1053 readJsonResourceFileAsObject("/payload_jsons/vfModuleCreate2AndPauseRequest.json", ServiceInstantiation.class), "userId")
1056 String createPath= "/serviceInstantiation/v7/serviceInstances/f8791436-8d55-4fde-b4d5-72dd2cf13cfb/vnfs/VNF_INSTANCE_ID/vfModules";
1058 when(restMso.restCall(eq(HttpMethod.POST), eq(RequestReferencesContainer.class), any(), eq(createPath), any())).thenReturn(createVfModuleResponse);
1059 when(restMso.GetForObject(endsWith(createVfModuleResponse.get().getRequestReferences().getRequestId()), eq(AsyncRequestStatus.class))).thenReturn(createStatusResponse);
1062 processJobsCountTimesAndAssertStatus(jobUUID, 40, expectedJobStatus);
1064 verify(restMso, times(expectedNumberOfInvocation)).restCall(eq(HttpMethod.POST), any(), any(), eq(createPath), any());
1067 //this test is going along with AsyncInstantiationALaCarteApiTest.delete1Create1NetworkFromService API test
1068 //The API test has only the happy flow scenario, while this test also test additional MSO responses (mostly non happy)
1069 @Test(dataProvider="createAndDeleteIntegrationTestDataProvider")
1070 public void networksIntegrationTest(
1072 RestObject<RequestReferencesContainer> createNetworkResponse,
1073 RestObject<RequestReferencesContainer> deleteNetworkResponse,
1074 RestObject<AsyncRequestStatus> createStatusResponse,
1075 RestObject<AsyncRequestStatus> deleteStatusResponse,
1076 JobStatus expectedJobStatus,
1077 int getStatusCounter) {
1079 createAndDeleteIntegrationTest("/payload_jsons/networkDelete1Create1Request.json",
1080 "/serviceInstantiation/v7/serviceInstances/f8791436-8d55-4fde-b4d5-72dd2cf13cfb/networks",
1081 createNetworkResponse,
1082 "/serviceInstantiation/v7/serviceInstances/f8791436-8d55-4fde-b4d5-72dd2cf13cfb/networks/NETWORK_INSTANCE_ID",
1083 deleteNetworkResponse,
1084 createStatusResponse,
1085 deleteStatusResponse,
1090 private UUID createAndDeleteIntegrationTest(String payload,
1092 RestObject<RequestReferencesContainer> createResponse,
1094 RestObject<RequestReferencesContainer> deleteResponse,
1095 RestObject<AsyncRequestStatus> createStatusResponse,
1096 RestObject<AsyncRequestStatus> deleteStatusResponse,
1097 JobStatus expectedJobStatus,
1098 int getStatusCounter) {
1099 UUID jobUUID = asyncInstantiationBL.pushBulkJob(
1100 readJsonResourceFileAsObject(payload, ServiceInstantiation.class), "userId")
1103 when(restMso.restCall(eq(HttpMethod.POST), eq(RequestReferencesContainer.class), any(), eq(createPath), any())).thenReturn(createResponse);
1104 when(restMso.restCall(eq(HttpMethod.DELETE), eq(RequestReferencesContainer.class), any(), eq(deletePath), any())).thenReturn(deleteResponse);
1105 if (createStatusResponse!=null) {
1106 when(restMso.GetForObject(endsWith(createResponse.get().getRequestReferences().getRequestId()), eq(AsyncRequestStatus.class))).thenReturn(createStatusResponse);
1108 if (deleteStatusResponse!=null) {
1109 when(restMso.GetForObject(endsWith(deleteResponse.get().getRequestReferences().getRequestId()), eq(AsyncRequestStatus.class))).thenReturn(deleteStatusResponse);
1112 processJobsCountTimesAndAssertStatus(jobUUID, 40, expectedJobStatus);
1114 verify(restMso, times(1)).restCall(eq(HttpMethod.POST), any(), any(), eq(createPath), any());
1115 verify(restMso, times(1)).restCall(eq(HttpMethod.DELETE), any(), any(), eq(deletePath), any());
1116 verify(restMso, times(getStatusCounter)).GetForObject(any(), any());
1122 public void whenCreateTransportService_thanExpectedPre1806MacroRequestSent() {
1123 UUID jobUUID = asyncInstantiationBL.pushBulkJob(generatePre1806MacroTransportServiceInstantiationPayload(null, null),"az2016").get(0);
1124 RestObject<RequestReferencesContainer> createResponse = createResponseRandomIds(202);
1126 when(restMso.restCall(eq(HttpMethod.POST), eq(RequestReferencesContainer.class), any(), eq("/serviceInstantiation/v7/serviceInstances"), any()))
1127 .thenReturn(createResponse);
1128 when(restMso.GetForObject(endsWith(createResponse.get().getRequestReferences().getRequestId()), eq(AsyncRequestStatus.class)))
1129 .thenReturn(asyncRequestStatusResponseAsRestObject(COMPLETE_STR));
1130 processJobsCountTimesAndAssertStatus(jobUUID, 20, COMPLETED);
1132 JsonNode expectedJson = readJsonResourceFileAsObject("/payload_jsons/pre_1806_macro_without_cloudConfiguration.json", JsonNode.class);
1133 ArgumentCaptor<RequestDetailsWrapper> requestCaptor = ArgumentCaptor.forClass(RequestDetailsWrapper.class);
1134 verify(restMso).restCall(any(), any(), requestCaptor.capture(), any(), any());
1135 requestCaptor.getAllValues().forEach(x->assertJsonEquals(expectedJson, x));
1138 private void assertErrorForResource(BaseResource resource,
1139 RestObject<RequestReferencesContainer> deleteOrCreateResponse,
1140 RestObject<AsyncRequestStatus> statusResponse) {
1141 JobAuditStatus auditStatus = auditService.getResourceAuditStatus(resource.getTrackById());
1142 assertThat(auditStatus, is(notNullValue()));
1143 assertThat(auditStatus.getJobStatus(), equalTo(FAILED_STR));
1144 if (statusResponse == null) {
1145 String errorMessage = "Http Code:" + deleteOrCreateResponse.getStatusCode() + ", " + RAW_DATA_FROM_MSO;
1146 assertThat(auditStatus.getAdditionalInfo(), equalTo(errorMessage));
1147 assertThat(auditStatus.getRequestId(), is(nullValue()));
1149 assertThat(auditStatus.getRequestId().toString(), equalTo(statusResponse.get().request.requestId));
1153 protected void processJobsCountTimesAndAssertStatus(UUID serviceJobId, int times, JobStatus expectedStatus) {
1154 processJobsCountTimes(times);
1155 singleServicesAndAssertStatus(expectedStatus, serviceJobId);
1158 private void processJobsCountTimes(int times) {
1159 for (int i = 0; i < times; i++) {
1160 WORKERS_TOPICS.forEach(this::simplePullJobProcessAndPushBack);
1164 protected void processJobsCountTimesAndAssertStatus(UUID serviceJobId, int times, JobStatus expectedStatus, JobStatus otherJobsStatus) {
1165 processJobsCountTimes(times);
1166 listServicesAndAssertStatus(expectedStatus, otherJobsStatus, serviceJobId);
1170 private void verifyQueueSizes(ImmutableMap<JobStatus, Integer> expected) {
1171 final Collection<Job> peek = jobsBrokerService.peek();
1172 final Map<JobStatus, Long> jobTypes = peek.stream().collect(groupingBy(Job::getStatus, counting()));
1173 assertThat(jobTypes, jsonEquals(expected));
1176 private List<ServiceInfo> listServicesAndAssertStatus(JobStatus pulledJobStatus, JobStatus otherJobsStatus, UUID jobUUID) {
1177 List<ServiceInfo> serviceInfoList = asyncInstantiationBL.getAllServicesInfo();
1178 assertServicesStatus(serviceInfoList, pulledJobStatus, otherJobsStatus, jobUUID);
1180 return serviceInfoList;
1183 private ServiceInfo singleServicesAndAssertStatus(JobStatus expectedStatus, UUID jobUUID) {
1184 List<ServiceInfo> serviceInfoList = asyncInstantiationBL.getAllServicesInfo();
1185 assertEquals(1, serviceInfoList.size());
1186 ServiceInfo serviceInfo = serviceInfoList.get(0);
1187 assertThat(serviceInfo.getJobStatus(), is(expectedStatus));
1188 assertThat(serviceInfo.getJobId(), is(jobUUID));
1192 private boolean isServiceOnStatus(JobStatus expectedStatus) {
1193 List<ServiceInfo> serviceInfoList = asyncInstantiationBL.getAllServicesInfo();
1194 assertEquals(1, serviceInfoList.size());
1195 return serviceInfoList.get(0).getJobStatus()==expectedStatus;
1198 private void assertServicesStatus(List<ServiceInfo> serviceInfoList, JobStatus pulledJobStatus, JobStatus otherJobsStatus, UUID jobUUID) {
1199 serviceInfoList.forEach(si->{
1200 if (si.getJobId().equals(jobUUID)) {
1201 assertThat(si.getJobStatus(), is(pulledJobStatus));
1204 assertThat(si.getJobStatus(), is(otherJobsStatus));
1209 private void listServicesAndAssertStatus(Map<UUID, JobStatus> expectedJobStatusMap) {
1210 Map<UUID, JobStatus> actualStatuses = asyncInstantiationBL.getAllServicesInfo()
1211 .stream().collect(Collectors.toMap(ServiceInfo::getJobId, ServiceInfo::getJobStatus));
1212 assertThat(actualStatuses.entrySet(), equalTo(expectedJobStatusMap.entrySet()));
1215 private String randomUuid() {
1216 return UUID.randomUUID().toString();
1220 public void whenResumeService_thanExpectedResumeRequestSent() {
1221 String instanceId = "a565e6ad-75d1-4493-98f1-33234b5c17e2"; //from feRequestResumeMacroService.json
1222 String originalRequestId = "894089b8-f7f4-418d-81da-34186fd32670"; //from msoResponseGetRequestsOfServiceInstance.json
1223 String resumeRequestId = randomUuid();
1224 String userId = TestUtils.generateRandomAlphaNumeric(6);
1226 //prepare mocks for get all requests for instance id
1227 RestObject<AsyncRequestStatusList> getRequestByIdResponse = createAsyncRequestStatusListByInstanceId();
1228 when(restMso.GetForObject(
1229 eq("/orchestrationRequests/v7?filter=serviceInstanceId:EQUALS:" + instanceId),
1230 eq(AsyncRequestStatusList.class)))
1231 .thenReturn(getRequestByIdResponse);
1233 //prepare mocks resume request
1234 when(restMso.restCall(eq(HttpMethod.POST), eq(RequestReferencesContainer.class), isNull(), eq(String.format("/orchestrationRequests/v7/%s/resume", originalRequestId)), eq(Optional.of(userId))))
1235 .thenReturn(createResponse(202, instanceId, resumeRequestId));
1237 //prepare mocks for get resume status
1238 when(restMso.GetForObject(eq("/orchestrationRequests/v7/" + resumeRequestId), eq(AsyncRequestStatus.class)))
1239 .thenReturn(asyncRequestStatusResponseAsRestObject(IN_PROGRESS_STR),
1240 asyncRequestStatusResponseAsRestObject(IN_PROGRESS_STR),
1241 asyncRequestStatusResponseAsRestObject(COMPLETE_STR));
1244 UUID jobUUID = asyncInstantiationBL.pushBulkJob(generateResumeMacroPayload(), userId).get(0);
1245 processJobsCountTimesAndAssertStatus(jobUUID, 20, COMPLETED);
1246 verify(restMso).GetForObject(
1247 eq("/orchestrationRequests/v7?filter=serviceInstanceId:EQUALS:" + instanceId),
1248 eq(AsyncRequestStatusList.class));
1249 verify(restMso).restCall(eq(HttpMethod.POST), eq(RequestReferencesContainer.class), isNull(), eq(String.format("/orchestrationRequests/v7/%s/resume", originalRequestId)), eq(Optional.of(userId)));
1250 verify(restMso, times(3)).GetForObject(eq("/orchestrationRequests/v7/" + resumeRequestId), eq(AsyncRequestStatus.class));
1254 public void givenResumeRequest_whenMsoReturnBadResponse_thanJobIsFailed() {
1255 //there is no mocks for restMSO which means restMso return bad response...
1256 UUID jobUUID = asyncInstantiationBL.pushBulkJob(generateResumeMacroPayload(), "abc").get(0);
1257 processJobsCountTimesAndAssertStatus(jobUUID, 20, FAILED);
1261 private RestObject<AsyncRequestStatusList> createAsyncRequestStatusListByInstanceId() {
1262 AsyncRequestStatusList asyncRequestStatusList = readJsonResourceFileAsObject(
1263 "/payload_jsons/resume/msoResponseGetRequestsOfServiceInstance.json",
1264 AsyncRequestStatusList.class);
1265 RestObject<AsyncRequestStatusList> getRequestByIdResponse = new RestObject<>();
1266 getRequestByIdResponse.set(asyncRequestStatusList);
1267 getRequestByIdResponse.setStatusCode(200);
1268 return getRequestByIdResponse;
1271 private ServiceInstantiation generateResumeMacroPayload() {
1272 return readJsonResourceFileAsObject("/payload_jsons/resume/feRequestResumeMacroService.json", ServiceInstantiation.class);
1276 public void whenUpgradingVfModule_thenExpectedReplaceRequestSent() throws AsdcCatalogException {
1277 String currentServiceInstanceId = "6196ab1f-2349-4b32-9b6c-cffeb0ccc79c";
1278 String currentVnfInstanceId = "d520268f-7489-4662-be59-f81495b3a069";
1279 String currentVfModuleInstanceId = "b0732bed-3ddf-43cc-b193-7f18db84e476";
1281 assertTestPayloadFitsExpectedIds(upgradeVfModulePayload(), currentServiceInstanceId, currentVnfInstanceId, currentVfModuleInstanceId);
1283 String replaceRequestId = randomUuid();
1284 String userId = "az2016";
1286 String modelInvariantId = "b3a1a119-dede-4ed0-b077-2a617fa519a3";
1287 String newestModelUuid = "d9a5b318-187e-476d-97f7-a15687a927a9";
1289 String expectedMsoReplacePath = "/serviceInstantiation/v7/serviceInstances/"
1290 + currentServiceInstanceId + "/vnfs/" + currentVnfInstanceId + "/vfModules/" + currentVfModuleInstanceId + "/replace";
1292 when(commandUtils.getNewestModelUuid(eq(modelInvariantId))).thenReturn(newestModelUuid);
1293 when(commandUtils.getServiceModel(eq(newestModelUuid))).thenReturn(newestServiceModel());
1295 when(restMso.restCall(eq(HttpMethod.POST), eq(RequestReferencesContainer.class), any(), eq(expectedMsoReplacePath), eq(Optional.of(userId))))
1296 .thenReturn(createResponse(202, currentVfModuleInstanceId, replaceRequestId));
1298 when(restMso.GetForObject(eq("/orchestrationRequests/v7/" + replaceRequestId), eq(AsyncRequestStatus.class)))
1299 .thenReturn(asyncRequestStatusResponseAsRestObject(IN_PROGRESS_STR),
1300 asyncRequestStatusResponseAsRestObject(IN_PROGRESS_STR),
1301 asyncRequestStatusResponseAsRestObject(COMPLETE_STR));
1303 enableAddCloudOwnerOnMsoRequest();
1306 UUID jobUUID = asyncInstantiationBL.pushBulkJob(upgradeVfModulePayload(), userId).get(0);
1307 processJobsCountTimesAndAssertStatus(jobUUID, 20, COMPLETED);
1310 ArgumentCaptor<RequestDetailsWrapper> requestCaptor = ArgumentCaptor.forClass(RequestDetailsWrapper.class);
1311 verify(restMso, times(1)).restCall(
1312 eq(HttpMethod.POST),
1313 eq(RequestReferencesContainer.class),
1314 requestCaptor.capture(),
1315 eq(expectedMsoReplacePath),
1316 eq(Optional.of(userId))
1319 JsonNode expectedPayloadToMso = readJsonResourceFileAsObject("/payload_jsons/vfmodule/upgrade_vfmodule_e2e__payload_to_mso.json", JsonNode.class);
1320 assertThat(requestCaptor.getValue(), jsonEquals(expectedPayloadToMso).when(IGNORING_ARRAY_ORDER));
1324 public void viewEdit_oneNetworkExistsAddAnotherNetwork() {
1325 String currentServiceInstanceId = "ce2821fc-3b28-4759-9613-1e514d7563c0";
1326 String addNetworkRequestId = randomUuid();
1327 String userId = "az2016";
1330 String expectedMsoAddNetworkPath =
1331 "/serviceInstantiation/v7/serviceInstances/" + currentServiceInstanceId + "/networks";
1333 when(restMso.restCall(eq(HttpMethod.POST),eq(RequestReferencesContainer.class),any(), eq(expectedMsoAddNetworkPath), any()))
1334 .thenReturn(createResponse(202, currentServiceInstanceId, addNetworkRequestId));
1336 when(restMso.GetForObject(eq("/orchestrationRequests/v7/" + addNetworkRequestId),eq(AsyncRequestStatus.class)))
1337 .thenReturn(asyncRequestStatusResponseAsRestObject(COMPLETE_STR));
1339 List<UUID> uuids= asyncInstantiationBL.pushBulkJob(addNetworkBulkPayload(), userId);
1340 assertThat(uuids, hasSize(1));
1341 processJobsCountTimesAndAssertStatus(uuids.get(0), 200, COMPLETED);
1343 verify(restMso, times(1)).restCall(eq(HttpMethod.POST), any(), any(), eq(expectedMsoAddNetworkPath),any());
1344 verify(restMso, times(1)).GetForObject(any(),any());
1348 public void whenDeletingVfModule_thenExpectedDeleteRequestSent()
1350 String currentServiceInstanceId = "6196ab1f-2349-4b32-9b6c-cffeb0ccc79c";
1351 String currentVnfInstanceId = "d520268f-7489-4662-be59-f81495b3a069";
1352 String currentVfModuleInstanceId = "b0732bed-3ddf-43cc-b193-7f18db84e476";
1354 assertTestPayloadFitsExpectedIds(deleteVfModuleBulkPayload(), currentServiceInstanceId, currentVnfInstanceId, currentVfModuleInstanceId);
1356 String deleteRequestId = randomUuid();
1357 String userId = "az2016";
1360 String expectedMsoDeletePath = "/serviceInstantiation/v7/serviceInstances/"
1361 + currentServiceInstanceId + "/vnfs/" + currentVnfInstanceId + "/vfModules/" + currentVfModuleInstanceId;
1363 when(restMso.restCall(eq(HttpMethod.DELETE), eq(RequestReferencesContainer.class), any(), eq(expectedMsoDeletePath), eq(Optional.of(userId))))
1364 .thenReturn(createResponse(202, currentVfModuleInstanceId, deleteRequestId));
1366 when(restMso.GetForObject(eq("/orchestrationRequests/v7/" + deleteRequestId), eq(AsyncRequestStatus.class)))
1367 .thenReturn(asyncRequestStatusResponseAsRestObject(IN_PROGRESS_STR),
1368 asyncRequestStatusResponseAsRestObject(IN_PROGRESS_STR),
1369 asyncRequestStatusResponseAsRestObject(COMPLETE_STR));
1371 enableAddCloudOwnerOnMsoRequest();
1374 UUID jobUUID = asyncInstantiationBL.pushBulkJob(deleteVfModuleBulkPayload(), userId).get(0);
1375 processJobsCountTimesAndAssertStatus(jobUUID, 20, COMPLETED);
1378 ArgumentCaptor<RequestDetailsWrapper> requestCaptor = ArgumentCaptor.forClass(RequestDetailsWrapper.class);
1379 verify(restMso, times(1)).restCall(
1380 eq(HttpMethod.DELETE),
1381 eq(RequestReferencesContainer.class),
1382 requestCaptor.capture(),
1383 eq(expectedMsoDeletePath),
1384 eq(Optional.of(userId))
1387 assertThat(requestCaptor.getValue(), jsonEquals(getDeleteVfModulePayloadToMso()));
1391 private ServiceInstantiation deleteVfModuleBulkPayload() {
1392 return readJsonResourceFileAsObject("/payload_jsons/vfmodule/delete_1_vfmodule_expected_bulk.json", ServiceInstantiation.class);
1395 private ServiceInstantiation addNetworkBulkPayload() {
1396 return readJsonResourceFileAsObject("/payload_jsons/Network/one_network_exists_add_another_network_expected_bulk.json", ServiceInstantiation.class);
1399 private String getDeleteVfModulePayloadToMso() {
1401 " \"requestDetails\": { " +
1402 " \"requestInfo\": { " +
1403 " \"source\": \"VID\", " +
1404 " \"requestorId\": \"az2016\" " +
1406 " \"modelInfo\": { " +
1407 " \"modelType\": \"vfModule\", " +
1408 " \"modelName\": \"XbiTestModuleReplace..base_ocg..module-0\", " +
1409 " \"modelVersionId\": \"04b21d26-9780-4956-8329-b22b049329f4\", " +
1410 " \"modelVersion\": \"1.0\", " +
1411 " \"modelInvariantId\": \"d887658e-2a89-4baf-83e2-b189601a1a7c\", " +
1412 " \"modelCustomizationName\": \"XbiTestModuleReplace..base_ocg..module-0\", " +
1413 " \"modelCustomizationId\": \"3f1f0fcb-8a88-4612-a794-3912613ed9e8\" " +
1415 " \"cloudConfiguration\": { " +
1416 " \"lcpCloudRegionId\": \"olson5a\", " +
1417 " \"cloudOwner\": \"irma-aic\", " +
1418 " \"tenantId\": \"7ff7b1a4fe954f71ab79d3160ec3eb08\" " +
1424 private void assertTestPayloadFitsExpectedIds(ServiceInstantiation upgradeVfModulePayload, String serviceInstanceId,
1425 String vnfInstanceId, String vfModuleInstanceId) {
1427 Just verifies the test and the input-file are using the same set of instance IDs
1429 assertThat(upgradeVfModulePayload, jsonPartEquals("instanceId", serviceInstanceId));
1430 assertThat(upgradeVfModulePayload, jsonNodePresent(
1432 + "." + vnfInstanceId
1434 + ".xbitestmodulereplace0\\.\\.XbiTestModuleReplace\\.\\.base_ocg\\.\\.module-0"
1435 + "." + vfModuleInstanceId));
1438 private ServiceModel newestServiceModel() {
1439 return readJsonResourceFileAsObject("/payload_jsons/vfmodule/upgrade_vfmodule_e2e__target_newest_service_model.json", ServiceModel.class);
1442 private ServiceInstantiation upgradeVfModulePayload() {
1443 return readJsonResourceFileAsObject("/payload_jsons/vfmodule/upgrade_vfmodule_e2e__fe_input_cypress.json", ServiceInstantiation.class);
1447 public void deployService_failIt_retryDeploy_getRetryAsTemplate_makeSureFalsyIsFailedInTemplate() {
1449 final String SERVICE_REQUEST_ID = UUID.randomUUID().toString();
1451 //push alacarte with 1 vnf, verify STATUS pending
1452 UUID uuid = pushALaCarteWithVnf();
1453 singleServicesAndAssertStatus(JobStatus.PENDING, uuid);
1455 //mock mso to answer 200 of create service instance request, verify STATUS in progress
1456 when(restMso.restCall(eq(HttpMethod.POST), eq(RequestReferencesContainer.class), any(), endsWith("serviceInstances"), any())).thenReturn(
1457 createResponse(200, SERVICE_INSTANCE_ID, SERVICE_REQUEST_ID));
1459 //mock mso to answer FAILED for service instance create
1460 final RestObject<AsyncRequestStatus> failedResponse = asyncRequestStatusResponseAsRestObject(FAILED_STR);
1461 final String failureDescription = "Some deep failure";
1462 failedResponse.get().request.requestStatus.setStatusMessage(failureDescription);
1463 when(restMso.GetForObject(endsWith(SERVICE_REQUEST_ID), eq(AsyncRequestStatus.class))).
1464 thenReturn(failedResponse);
1466 //Wait till job failed
1467 processJobsCountTimesAndAssertStatus(uuid, 3, FAILED);
1469 //make sure retry request jas isFailed = true, and status message is with failureDescription
1470 ServiceInstantiation retryRequest = asyncInstantiationBL.getBulkForRetry(uuid);
1471 assertTrue(retryRequest.getIsFailed());
1472 assertEquals(failureDescription, retryRequest.getStatusMessage());
1474 //deploy retry job and it's template
1475 UUID retryUuid = asyncInstantiationBL.pushBulkJob(retryRequest, USER_ID).get(0);
1476 ServiceInstantiation templateOfRetry = instantiationTemplates.getJobRequestAsTemplate(retryUuid);
1478 //make sure the template request has isFailed = false, and no status message
1479 assertFalse(templateOfRetry.getIsFailed());
1480 assertNull(templateOfRetry.getStatusMessage());
1484 public void oneVnfExistsAddAnotherVnf(){
1485 final String VNF_REQUEST_ID = UUID.randomUUID().toString();
1486 final String VNF_INSTANCE_ID = UUID.randomUUID().toString();
1488 ServiceInstantiation serviceInstantiation = readJsonResourceFileAsObject("/payload_jsons/vnf/one_vnf_exists_add_another_vnf_expected_bulk.json",
1489 ServiceInstantiation.class);
1490 List<UUID> uuids = asyncInstantiationBL.pushBulkJob(serviceInstantiation, USER_ID);
1491 assertThat(uuids, hasSize(1));
1493 //mock mso to answer 200 of create vnf instance request
1494 when(restMso.restCall(eq(HttpMethod.POST), eq(RequestReferencesContainer.class), any(), endsWith("e6cc1c4f-05f7-49bc-8e86-ac2eb92baaaa/vnfs"), any())).thenReturn(
1495 createResponse(200, VNF_INSTANCE_ID, VNF_REQUEST_ID));
1497 //mock mso to answer msoVnfStatus (COMPLETE) for vnf creation status,
1498 when(restMso.GetForObject(endsWith(VNF_REQUEST_ID), eq(AsyncRequestStatus.class))).
1499 thenReturn(asyncRequestStatusResponseAsRestObject(COMPLETE_STR));
1501 processJobsCountTimesAndAssertStatus(uuids.get(0), 200, COMPLETED);
1502 verify(restMso, times(1)).restCall(eq(HttpMethod.POST), any(), any(), endsWith("e6cc1c4f-05f7-49bc-8e86-ac2eb92baaaa/vnfs"), any());
1503 verify(restMso, times(1)).GetForObject(any(), any());