1 package org.onap.vid.services;
3 import static com.google.common.collect.Maps.newHashMap;
4 import static org.hamcrest.MatcherAssert.assertThat;
5 import static org.hamcrest.Matchers.contains;
6 import static org.hamcrest.Matchers.hasItem;
7 import static org.hamcrest.Matchers.hasItems;
8 import static org.hamcrest.Matchers.hasProperty;
9 import static org.hamcrest.Matchers.is;
10 import static org.hamcrest.Matchers.matchesPattern;
11 import static org.hamcrest.Matchers.not;
12 import static org.hamcrest.core.Every.everyItem;
13 import static org.hamcrest.core.IsEqual.equalTo;
14 import static org.mockito.Matchers.any;
15 import static org.mockito.Mockito.anyInt;
16 import static org.mockito.Mockito.anyString;
17 import static org.mockito.Mockito.doNothing;
18 import static org.mockito.Mockito.doThrow;
19 import static org.mockito.Mockito.eq;
20 import static org.mockito.Mockito.mock;
21 import static org.mockito.Mockito.times;
22 import static org.mockito.Mockito.verify;
23 import static org.mockito.Mockito.when;
24 import static org.onap.vid.job.Job.JobStatus.COMPLETED;
25 import static org.onap.vid.job.Job.JobStatus.FAILED;
26 import static org.onap.vid.job.Job.JobStatus.IN_PROGRESS;
27 import static org.onap.vid.job.Job.JobStatus.PAUSE;
28 import static org.onap.vid.job.Job.JobStatus.PENDING;
29 import static org.onap.vid.job.Job.JobStatus.STOPPED;
30 import static org.testng.Assert.assertEquals;
31 import static org.testng.Assert.assertFalse;
32 import static org.testng.Assert.assertNotNull;
33 import static org.testng.Assert.assertNull;
34 import static org.testng.Assert.assertTrue;
36 import com.fasterxml.jackson.databind.JsonNode;
37 import com.fasterxml.jackson.databind.ObjectMapper;
38 import com.google.common.collect.ImmutableList;
39 import com.google.common.collect.ImmutableMap;
40 import java.io.IOException;
41 import java.lang.reflect.Method;
43 import java.time.Instant;
44 import java.time.LocalDateTime;
45 import java.time.ZoneId;
46 import java.util.ArrayList;
47 import java.util.Arrays;
48 import java.util.Collections;
49 import java.util.Comparator;
50 import java.util.Date;
51 import java.util.HashMap;
52 import java.util.List;
54 import java.util.Optional;
56 import java.util.UUID;
57 import java.util.concurrent.Callable;
58 import java.util.concurrent.ExecutorService;
59 import java.util.concurrent.Executors;
60 import java.util.stream.Collectors;
61 import java.util.stream.IntStream;
62 import javax.inject.Inject;
63 import net.javacrumbs.jsonunit.JsonAssert;
64 import org.apache.commons.io.IOUtils;
65 import org.hibernate.SessionFactory;
66 import org.json.JSONException;
67 import org.mockito.ArgumentCaptor;
68 import org.mockito.Mock;
69 import org.mockito.Mockito;
70 import org.mockito.MockitoAnnotations;
71 import org.mockito.stubbing.Answer;
72 import org.onap.portalsdk.core.domain.FusionObject;
73 import org.onap.portalsdk.core.service.DataAccessService;
74 import org.onap.portalsdk.core.util.SystemProperties;
75 import org.onap.vid.aai.ExceptionWithRequestInfo;
76 import org.onap.vid.aai.model.ResourceType;
77 import org.onap.vid.changeManagement.RequestDetailsWrapper;
78 import org.onap.vid.config.DataSourceConfig;
79 import org.onap.vid.config.MockedAaiClientAndFeatureManagerConfig;
80 import org.onap.vid.exceptions.GenericUncheckedException;
81 import org.onap.vid.exceptions.MaxRetriesException;
82 import org.onap.vid.exceptions.OperationNotAllowedException;
83 import org.onap.vid.job.Job;
84 import org.onap.vid.job.Job.JobStatus;
85 import org.onap.vid.job.JobAdapter;
86 import org.onap.vid.job.JobType;
87 import org.onap.vid.job.JobsBrokerService;
88 import org.onap.vid.job.impl.JobDaoImpl;
89 import org.onap.vid.job.impl.JobSharedData;
90 import org.onap.vid.model.Action;
91 import org.onap.vid.model.JobAuditStatus;
92 import org.onap.vid.model.JobAuditStatus.SourceStatus;
93 import org.onap.vid.model.NameCounter;
94 import org.onap.vid.model.ServiceInfo;
95 import org.onap.vid.model.serviceInstantiation.InstanceGroup;
96 import org.onap.vid.model.serviceInstantiation.Network;
97 import org.onap.vid.model.serviceInstantiation.ServiceInstantiation;
98 import org.onap.vid.model.serviceInstantiation.VfModule;
99 import org.onap.vid.model.serviceInstantiation.Vnf;
100 import org.onap.vid.mso.MsoOperationalEnvironmentTest;
101 import org.onap.vid.mso.model.InstanceGroupInstantiationRequestDetails;
102 import org.onap.vid.mso.model.ModelInfo;
103 import org.onap.vid.mso.model.NetworkInstantiationRequestDetails;
104 import org.onap.vid.mso.model.ServiceDeletionRequestDetails;
105 import org.onap.vid.mso.model.ServiceInstantiationRequestDetails;
106 import org.onap.vid.mso.model.VfModuleInstantiationRequestDetails;
107 import org.onap.vid.mso.model.VfModuleMacro;
108 import org.onap.vid.mso.model.VnfInstantiationRequestDetails;
109 import org.onap.vid.mso.model.VolumeGroupRequestDetails;
110 import org.onap.vid.mso.rest.AsyncRequestStatus;
111 import org.onap.vid.properties.Features;
112 import org.onap.vid.testUtils.TestUtils;
113 import org.onap.vid.utils.DaoUtils;
114 import org.springframework.beans.factory.annotation.Autowired;
115 import org.springframework.test.context.ContextConfiguration;
116 import org.testng.Assert;
117 import org.testng.annotations.AfterMethod;
118 import org.testng.annotations.BeforeClass;
119 import org.testng.annotations.BeforeMethod;
120 import org.testng.annotations.DataProvider;
121 import org.testng.annotations.Test;
123 @ContextConfiguration(classes = {DataSourceConfig.class, SystemProperties.class, MockedAaiClientAndFeatureManagerConfig.class})
124 public class AsyncInstantiationBusinessLogicTest extends AsyncInstantiationBaseTest {
127 private DataAccessService dataAccessService;
130 private JobAdapter jobAdapterMock;
133 private JobsBrokerService jobsBrokerServiceMock;
137 private SessionFactory sessionFactory;
139 private AsyncInstantiationBusinessLogicImpl asyncInstantiationBL;
141 private int serviceCount = 0;
143 private static final String UPDATE_SERVICE_INFO_EXCEPTION_MESSAGE =
144 "Failed to retrieve job with uuid .* from ServiceInfo table. Instances found: .*";
146 private static final String DELETE_SERVICE_INFO_STATUS_EXCEPTION_MESSAGE =
147 "Service status does not allow deletion from the queue";
150 void initServicesInfoService() {
151 MockitoAnnotations.initMocks(this);
152 asyncInstantiationBL = new AsyncInstantiationBusinessLogicImpl(dataAccessService, jobAdapterMock, jobsBrokerServiceMock, sessionFactory, aaiClient, featureManager, cloudOwnerService);
153 createInstanceParamsMaps();
158 Mockito.reset(aaiClient);
159 Mockito.reset(jobAdapterMock);
160 Mockito.reset(jobsBrokerServiceMock);
161 mockAaiClientAnyNameFree();
162 enableAddCloudOwnerOnMsoRequest();
165 private void enableAddCloudOwnerOnMsoRequest() {
166 enableAddCloudOwnerOnMsoRequest(true);
169 private void enableAddCloudOwnerOnMsoRequest(boolean isActive) {
170 // always turn on the feature flag
171 when(featureManager.isActive(Features.FLAG_1810_CR_ADD_CLOUD_OWNER_TO_MSO_REQUEST)).thenReturn(isActive);
172 when(aaiClient.getCloudOwnerByCloudRegionId(anyString())).thenReturn("att-aic");
176 void resetServiceCount() {
182 dataAccessService.deleteDomainObjects(JobDaoImpl.class, "1=1", getPropsMap());
183 dataAccessService.deleteDomainObjects(ServiceInfo.class, "1=1", getPropsMap());
184 dataAccessService.deleteDomainObjects(JobAuditStatus.class, "1=1", getPropsMap());
185 dataAccessService.deleteDomainObjects(NameCounter.class, "1=1", getPropsMap());
189 private void createNewTestServicesInfoForFilter(String userId) {
190 LocalDateTime createdDate, modifiedDate;
191 LocalDateTime NOW = LocalDateTime.now();
195 uuid = UUID.randomUUID();
197 createdDate = NOW.minusYears(1);
198 addNewServiceInfo(uuid, userId, "Old", createdDate, createdDate, COMPLETED, false);
200 uuid = UUID.randomUUID();
202 createdDate = NOW.minusDays(20);
203 modifiedDate = NOW.minusDays(19);
204 addNewServiceInfo(uuid, userId, "Hidden", createdDate, modifiedDate, PAUSE, true);
206 createNewTestServicesInfo(String.valueOf(userId));
209 private void createNewTestServicesInfo(String userId) {
211 LocalDateTime createdDate, modifiedDate;
212 LocalDateTime NOW = LocalDateTime.now();
215 uuid = UUID.randomUUID();
218 createdDate = NOW.minusDays(40);
219 addNewServiceInfo(uuid, userId, "service instance 5", createdDate, createdDate, COMPLETED, false);
220 addNewServiceInfo(uuid, userId, "service instance 6", createdDate, createdDate, STOPPED, false);
222 uuid = UUID.randomUUID();
225 createdDate = NOW.minusDays(20);
226 modifiedDate = NOW.minusDays(10);
227 addNewServiceInfo(uuid, userId, "service instance 4", createdDate, modifiedDate, STOPPED, false);
228 addNewServiceInfo(uuid, userId, "service instance 2", createdDate, modifiedDate, COMPLETED, false);
229 addNewServiceInfo(uuid, userId, "service instance 3", createdDate, modifiedDate, PAUSE, false);
231 modifiedDate = NOW.minusDays(19);
232 addNewServiceInfo(uuid, userId, "service instance 1", createdDate, modifiedDate, FAILED, false);
235 // Job to a different user
236 uuid = UUID.randomUUID();
239 createdDate = NOW.minusMonths(2);
240 addNewServiceInfo(uuid, "2221", "service instance 7", createdDate, createdDate, COMPLETED, false);
244 private UUID createServicesInfoWithDefaultValues(Job.JobStatus status) {
246 LocalDateTime NOW = LocalDateTime.now();
249 uuid = UUID.randomUUID();
250 addNewJob(uuid, status);
252 addNewServiceInfo(uuid, null, "service instance 1", NOW, NOW, status, false);
258 private List<ServiceInfo> getFullList() {
259 List<ServiceInfo> expectedOrderServiceInfo = dataAccessService.getList(ServiceInfo.class, getPropsMap());
260 assertThat("Failed to retrieve all predefined services", expectedOrderServiceInfo.size(), equalTo(serviceCount));
261 expectedOrderServiceInfo.sort(new ServiceInfoComparator());
262 return expectedOrderServiceInfo;
265 private static Date toDate(LocalDateTime localDateTime) {
266 return Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
269 private LocalDateTime fromDate(Date date) {
270 return Instant.ofEpochMilli(date.getTime())
271 .atZone(ZoneId.systemDefault())
275 private void addNewServiceInfo(UUID uuid, String userId, String serviceName, LocalDateTime createDate, LocalDateTime statusModifiedDate, Job.JobStatus status, boolean isHidden) {
276 ServiceInfo serviceInfo = new ServiceInfo();
277 serviceInfo.setJobId(uuid);
278 serviceInfo.setUserId(userId);
279 serviceInfo.setServiceInstanceName(serviceName);
280 serviceInfo.setStatusModifiedDate(toDate(statusModifiedDate));
281 serviceInfo.setJobStatus(status);
282 serviceInfo.setPause(false);
283 serviceInfo.setOwningEntityId("1234");
284 serviceInfo.setCreatedBulkDate(toDate(createDate));
286 serviceInfo.setHidden(isHidden);
287 dataAccessService.saveDomainObject(serviceInfo, getPropsMap());
288 setCreateDateToServiceInfo(uuid, createDate);
293 private void setCreateDateToServiceInfo(UUID jobUuid, LocalDateTime createDate) {
294 List<ServiceInfo> serviceInfoList = dataAccessService.getList(ServiceInfo.class, getPropsMap());
295 DaoUtils.tryWithSessionAndTransaction(sessionFactory, session -> {
296 serviceInfoList.stream()
297 .filter(serviceInfo -> jobUuid.equals(serviceInfo.getJobId()))
298 .forEach(serviceInfo -> {
299 serviceInfo.setCreated(toDate(createDate));
300 session.saveOrUpdate(serviceInfo);
306 private void addNewJob(UUID uuid) {
307 addNewJob(uuid, null);
310 private void addNewJob(UUID uuid, Job.JobStatus status) {
311 JobDaoImpl jobDao = new JobDaoImpl();
312 jobDao.setUuid(uuid);
313 jobDao.setStatus(status);
314 dataAccessService.saveDomainObject(jobDao, getPropsMap());
318 public void testServiceInfoAreOrderedAsExpected() {
320 createNewTestServicesInfo(String.valueOf(userId));
321 List<ServiceInfo> expectedOrderServiceInfo = getFullList();
322 List<ServiceInfo> serviceInfoListResult = asyncInstantiationBL.getAllServicesInfo();
323 assertThat("Services aren't ordered as expected", serviceInfoListResult, equalTo(expectedOrderServiceInfo));
327 public void testServiceInfoAreFilteredAsExpected() {
329 createNewTestServicesInfoForFilter(String.valueOf(userId));
330 List<ServiceInfo> expectedOrderServiceInfo = getFullList();
332 List<ServiceInfo> expectedFilterByUser = expectedOrderServiceInfo.stream().filter(x ->
333 !x.getServiceInstanceName().equals("Old") && !x.getServiceInstanceName().equals("Hidden")
335 ).collect(Collectors.toList());
338 List<ServiceInfo> serviceInfoFilteredByUser = asyncInstantiationBL.getAllServicesInfo();
339 assertThat("Services aren't ordered filtered as expected", serviceInfoFilteredByUser, equalTo(expectedFilterByUser));
342 @Test(dataProvider = "pauseAndInstanceParams")
343 public void createMacroServiceInstantiationMsoRequestUniqueName(Boolean isPause, HashMap<String, String> vfModuleInstanceParamsMap, List vnfInstanceParams) throws Exception {
345 ServiceInstantiation serviceInstantiationPayload = generateMockMacroServiceInstantiationPayload(isPause, createVnfList(vfModuleInstanceParamsMap, vnfInstanceParams, true), 2, true, PROJECT_NAME, false);
346 final URL resource = this.getClass().getResource("/payload_jsons/bulk_service_request_unique_names.json");
347 when(jobAdapterMock.createServiceInstantiationJob(any(), any(), any(), any(), anyString(), any())).thenAnswer(invocation -> {
348 Object[] args = invocation.getArguments();
349 return new MockedJob((String)args[4]);
352 when(jobsBrokerServiceMock.add(any(MockedJob.class))).thenAnswer((Answer<UUID>) invocation -> {
353 Object[] args = invocation.getArguments();
354 MockedJob job = (MockedJob) args[0];
355 MockedJob.putJob(job.uuid, job);
356 return job.getUuid();
359 when(featureManager.isActive(Features.FLAG_SHIFT_VFMODULE_PARAMS_TO_VNF)).thenReturn(true);
361 List<UUID> uuids = asyncInstantiationBL.pushBulkJob(serviceInstantiationPayload, "az2016");
362 for (int i = 0; i < 2; i++) {
363 UUID currentUuid = uuids.get(i);
364 RequestDetailsWrapper<ServiceInstantiationRequestDetails> result =
365 asyncInstantiationBL.generateMacroServiceInstantiationRequest(currentUuid, serviceInstantiationPayload,
366 MockedJob.getJob(currentUuid).getOptimisticUniqueServiceInstanceName(), "az2016");
367 String unique = i==0 ? "" : String.format("_00%s", i);
368 String expected = IOUtils.toString(resource, "UTF-8")
369 .replace("{SERVICE_UNIQENESS}", unique)
370 .replace("{VNF_UNIQENESS}", unique)
371 .replace("{VF_MODULE_UNIQENESS}", unique)
372 .replace("{VF_MODULE_2_UNIQENESS}", unique)
373 .replace("{VG_UNIQUENESS}", unique);
374 MsoOperationalEnvironmentTest.assertThatExpectationIsLikeObject(expected, result);
375 Optional<ServiceInfo> optionalServiceInfo = getJobById(currentUuid);
376 assertThat(optionalServiceInfo.get().getServiceInstanceName(), equalTo("vPE_Service" + unique));
377 verifySearchNodeTypeByName(unique, "vPE_Service", ResourceType.SERVICE_INSTANCE);
378 verifySearchNodeTypeByName(unique, VNF_NAME, ResourceType.GENERIC_VNF);
379 verifySearchNodeTypeByName(unique, "vmxnjr001_AVPN_base_vPE_BV_base", ResourceType.VF_MODULE);
380 verifySearchNodeTypeByName(unique, "vmxnjr001_AVPN_base_vRE_BV_expansion", ResourceType.VF_MODULE);
381 verifySearchNodeTypeByName(unique, "myVgName", ResourceType.VOLUME_GROUP);
385 protected void verifySearchNodeTypeByName(String unique, String resourceName, ResourceType serviceInstance) {
386 verify(aaiClient, times(1)).isNodeTypeExistsByName(resourceName + unique, serviceInstance);
389 private HashMap<String, Object> getPropsMap() {
390 HashMap<String, Object> props = new HashMap<>();
391 props.put(FusionObject.Parameters.PARAM_USERID, 0);
397 public static Object[][] dataProviderForInstanceNames() {
398 return new Object[][]{
399 {true, ImmutableList.of("vPE_Service", "vPE_Service_001", "vPE_Service_002")},
400 {false, ImmutableList.of("", "", "")},
404 @Test(dataProvider="dataProviderForInstanceNames")
405 public void pushBulkJob_bulkWithSize3_instancesNamesAreExactlyAsExpected(boolean isUserProvidedNaming, List<String> expectedNames) {
408 final ServiceInstantiation request = generateMockMacroServiceInstantiationPayload(
410 createVnfList(instanceParamsMapWithoutParams, Collections.EMPTY_LIST, true),
411 bulkSize, isUserProvidedNaming, PROJECT_NAME, true
414 // in "createServiceInstantiationJob()" we will probe the service, with the generated names
415 configureMockitoWithMockedJob();
418 asyncInstantiationBL.pushBulkJob(request, "myUserId");
420 List<ServiceInfo> serviceInfoList = dataAccessService.getList(ServiceInfo.class, getPropsMap());
421 assertEquals(serviceInfoList.stream().map(ServiceInfo::getServiceInstanceName).collect(Collectors.toList()), expectedNames);
424 @Test(dataProvider = "aLaCarteAndMacroPayload")
425 public void generateMockServiceInstantiationPayload_serializeBackAndForth_sourceShouldBeTheSame(ServiceInstantiation serviceInstantiationPayload) throws IOException {
426 ObjectMapper mapper = new ObjectMapper();
427 final String asString = mapper.writeValueAsString(serviceInstantiationPayload);
429 final ServiceInstantiation asObject = mapper.readValue(asString, ServiceInstantiation.class);
430 final String asString2 = mapper.writeValueAsString(asObject);
432 JsonAssert.assertJsonEquals(asString, asString2);
436 public Object[][] aLaCarteAndMacroPayload() {
437 ServiceInstantiation macroPayload = generateMockMacroServiceInstantiationPayload(
439 createVnfList(instanceParamsMapWithoutParams, ImmutableList.of(vnfInstanceParamsMapWithParamsToRemove, vnfInstanceParamsMapWithParamsToRemove), true),
440 2, false,PROJECT_NAME, false);
441 ServiceInstantiation aLaCartePayload = generateALaCarteServiceInstantiationPayload();
443 return new Object[][]{
449 public static class ServiceInfoComparator implements Comparator<ServiceInfo> {
452 public int compare(ServiceInfo o1, ServiceInfo o2) {
455 compare = o1.getCreatedBulkDate().compareTo(o2.getCreatedBulkDate());
460 // check jobStatus priority
461 int o1Priority = getPriority(o1);
462 int o2Priority = getPriority(o2);
463 compare = o1Priority - o2Priority;
468 // check statusModifiedDate
469 return o1.getStatusModifiedDate().compareTo(o2.getStatusModifiedDate());
472 private int getPriority(ServiceInfo o) throws JSONException {
473 Job.JobStatus status = o.getJobStatus();
492 public Object[][] pauseAndInstanceParams() {
493 return new Object[][]{
494 {Boolean.TRUE, instanceParamsMapWithoutParams, Collections.EMPTY_LIST},
495 {Boolean.FALSE, instanceParamsMapWithoutParams, Collections.EMPTY_LIST},
496 {Boolean.TRUE, vfModuleInstanceParamsMapWithParamsToRemove, Collections.singletonList(vnfInstanceParamsMapWithParamsToRemove)}
500 private ServiceInstantiation generateMacroMockServiceInstantiationPayload(boolean isPause, Map<String, Vnf> vnfs) {
501 return generateMockMacroServiceInstantiationPayload(isPause, vnfs, 1, true, PROJECT_NAME, false);
505 public void testUpdateServiceInfo_WithExistingServiceInfo_ServiceInfoIsUpdated() {
506 UUID uuid = createFakedJobAndServiceInfo();
507 final String STEPH_CURRY = "Steph Curry";
508 asyncInstantiationBL.updateServiceInfo(uuid, x -> {
509 x.setServiceInstanceName(STEPH_CURRY);
510 x.setJobStatus(Job.JobStatus.IN_PROGRESS);
512 Optional<ServiceInfo> optionalServiceInfo = getJobById(uuid);
513 assertThat(optionalServiceInfo.get().getServiceInstanceName(), equalTo(STEPH_CURRY));
514 assertThat(optionalServiceInfo.get().getJobStatus(), equalTo(Job.JobStatus.IN_PROGRESS));
517 private Optional<ServiceInfo> getJobById(UUID jobId) {
518 List<ServiceInfo> serviceInfoList = dataAccessService.getList(ServiceInfo.class, null);
519 return serviceInfoList.stream().filter(x -> jobId.equals(x.getJobId())).findFirst();
522 private UUID createFakedJobAndServiceInfo() {
523 UUID uuid = UUID.randomUUID();
525 ServiceInfo serviceInfo = new ServiceInfo();
526 serviceInfo.setServiceInstanceName("Lebron James");
527 serviceInfo.setJobId(uuid);
528 serviceInfo.setJobStatus(Job.JobStatus.PENDING);
529 dataAccessService.saveDomainObject(serviceInfo, getPropsMap());
533 @Test(expectedExceptions = GenericUncheckedException.class, expectedExceptionsMessageRegExp = UPDATE_SERVICE_INFO_EXCEPTION_MESSAGE)
534 public void testUpdateServiceInfo_WithNonExisting_ThrowException() {
535 asyncInstantiationBL.updateServiceInfo(UUID.randomUUID(), x -> x.setServiceInstanceName("not matter"));
538 @Test(expectedExceptions = GenericUncheckedException.class, expectedExceptionsMessageRegExp = UPDATE_SERVICE_INFO_EXCEPTION_MESSAGE)
539 public void testUpdateServiceInfo_WithDoubleServiceWithSameJobUuid_ThrowException() {
540 UUID uuid = createFakedJobAndServiceInfo();
541 ServiceInfo serviceInfo = new ServiceInfo();
542 serviceInfo.setJobId(uuid);
543 dataAccessService.saveDomainObject(serviceInfo, getPropsMap());
544 asyncInstantiationBL.updateServiceInfo(UUID.randomUUID(), x -> x.setServiceInstanceName("not matter"));
549 public static Object[][] isPauseAndPropertyDataProvider() {
550 return new Object[][]{
551 {true, "mso.restapi.serviceInstanceAssign"},
552 {false, "mso.restapi.serviceInstanceCreate"},
557 @Test(dataProvider = "isPauseAndPropertyDataProvider")
558 public void testServiceInstantiationPath_RequestPathIsAsExpected(boolean isPause, String expectedProperty) {
559 ServiceInstantiation serviceInstantiationPauseFlagTrue = generateMacroMockServiceInstantiationPayload(isPause, createVnfList(instanceParamsMapWithoutParams, Collections.EMPTY_LIST, true));
560 String path = asyncInstantiationBL.getServiceInstantiationPath(serviceInstantiationPauseFlagTrue);
561 Assert.assertEquals(path, SystemProperties.getProperty(expectedProperty));
565 public void testCreateVnfEndpoint_useProvidedInstanceId() {
566 String path = asyncInstantiationBL.getVnfInstantiationPath("myGreatId");
567 assertThat(path, matchesPattern("/serviceInstances/v./myGreatId/vnfs"));
571 public void createServiceInfo_WithUserProvidedNamingFalse_ServiceInfoIsAsExpected() throws IOException {
572 createMacroServiceInfo_WithUserProvidedNamingFalse_ServiceInfoIsAsExpected(true);
576 public void createServiceInfo_WithUserProvidedNamingFalseAndNoVfmodules_ServiceInfoIsAsExpected() throws IOException {
577 createMacroServiceInfo_WithUserProvidedNamingFalse_ServiceInfoIsAsExpected(false);
580 private void createMacroServiceInfo_WithUserProvidedNamingFalse_ServiceInfoIsAsExpected(boolean withVfmodules) throws IOException {
581 when(featureManager.isActive(Features.FLAG_SHIFT_VFMODULE_PARAMS_TO_VNF)).thenReturn(true);
583 ServiceInstantiation serviceInstantiationPayload = generateMockMacroServiceInstantiationPayload(true,
584 createVnfList(vfModuleInstanceParamsMapWithParamsToRemove, Collections.EMPTY_LIST, false),
586 false, PROJECT_NAME, true);
589 resource = this.getClass().getResource("/payload_jsons/bulk_service_request_ecomp_naming.json");
591 // remove the vf modules
592 serviceInstantiationPayload.getVnfs().values().forEach(vnf -> vnf.getVfModules().clear());
593 resource = this.getClass().getResource("/payload_jsons/bulk_service_request_no_vfmodule_ecomp_naming.json");
596 RequestDetailsWrapper<ServiceInstantiationRequestDetails> result =
597 asyncInstantiationBL.generateMacroServiceInstantiationRequest(null, serviceInstantiationPayload, serviceInstantiationPayload.getInstanceName(), "az2016");
599 String expected = IOUtils.toString(resource, "UTF-8");
600 MsoOperationalEnvironmentTest.assertThatExpectationIsLikeObject(expected, result);
604 public void createALaCarteService_WithUserProvidedNamingFalse_RequestDetailsIsAsExpected() throws IOException {
605 ServiceInstantiation serviceInstantiationPayload = generateMockALaCarteServiceInstantiationPayload(false,
610 false, PROJECT_NAME, true, null);
612 RequestDetailsWrapper<ServiceInstantiationRequestDetails> result =
613 asyncInstantiationBL.generateALaCarteServiceInstantiationRequest(null, serviceInstantiationPayload, serviceInstantiationPayload.getInstanceName(), "az2016");
615 URL resource = this.getClass().getResource("/payload_jsons/bulk_alacarte_service_request_naming_false.json");
616 String expected = IOUtils.toString(resource, "UTF-8");
617 MsoOperationalEnvironmentTest.assertThatExpectationIsLikeObject(expected, result);
621 public void generateALaCarteServiceInstantiationRequest_withVnfList_HappyFllow() throws IOException {
622 ServiceInstantiation serviceInstantiationPayload = generateALaCarteWithVnfsServiceInstantiationPayload();
623 RequestDetailsWrapper<ServiceInstantiationRequestDetails> result =
624 asyncInstantiationBL.generateALaCarteServiceInstantiationRequest(null, serviceInstantiationPayload, serviceInstantiationPayload.getInstanceName(), "az2016");
626 String serviceExpected = IOUtils.toString(this.getClass().getResource("/payload_jsons/bulk_alacarte_service_request.json"), "UTF-8");
627 MsoOperationalEnvironmentTest.assertThatExpectationIsLikeObject(serviceExpected, result);
630 @Test(dataProvider = "createVnfParameters")
631 public void createVnfRequestDetails_detailsAreAsExpected(boolean isFlagAddCloudOwnerActive, boolean isUserProvidedNaming, String file) throws IOException {
633 final List<Vnf> vnfList = new ArrayList<>(createVnfList(new HashMap<>(), null, isUserProvidedNaming, true).values());
634 ModelInfo siModelInfo = createServiceModelInfo();
635 String serviceInstanceId = "aa3514e3-5a33-55df-13ab-12abad84e7aa";
637 //we validate that the asyncInstantiationBL call to getUniqueName by simulate that aai retrun that original
638 //vnf name is used, and only next picked name is free.
639 Mockito.reset(aaiClient);
640 mockAaiClientAaiStatusOK();
641 when(aaiClient.isNodeTypeExistsByName(eq(VNF_NAME), eq(ResourceType.GENERIC_VNF))).thenReturn(true);
642 when(aaiClient.isNodeTypeExistsByName(eq(VNF_NAME+"_001"), eq(ResourceType.GENERIC_VNF))).thenReturn(false);
643 enableAddCloudOwnerOnMsoRequest(isFlagAddCloudOwnerActive);
645 String expected = IOUtils.toString(this.getClass().getResource(file), "UTF-8");
646 final RequestDetailsWrapper<VnfInstantiationRequestDetails> result = asyncInstantiationBL.generateVnfInstantiationRequest(vnfList.get(0), siModelInfo, serviceInstanceId, "pa0916");
647 MsoOperationalEnvironmentTest.assertThatExpectationIsLikeObject(expected, result);
651 public static Object[][] createVnfParameters() {
652 return new Object[][]{
653 {true, true, "/payload_jsons/bulk_vnf_request.json"},
654 {false, true, "/payload_jsons/bulk_vnf_request_without_cloud_owner.json"},
655 {true, false, "/payload_jsons/bulk_vnf_request_without_instance_name.json"},
660 public static Object[][] vfModuleRequestDetails(Method test) {
661 return new Object[][]{
662 {"cc3514e3-5a33-55df-13ab-12abad84e7cc", true, "/payload_jsons/vfmodule_instantiation_request.json"},
663 {null, true, "/payload_jsons/vfmodule_instantiation_request_without_volume_group.json"},
664 {null, false, "/payload_jsons/vfmodule_instantiation_request_without_instance_name.json"}
668 @Test(dataProvider = "vfModuleRequestDetails")
669 public void createVfModuleRequestDetails_detailsAreAsExpected(String volumeGroupInstanceId, boolean isUserProvidedNaming, String fileName) throws IOException {
671 ModelInfo siModelInfo = createServiceModelInfo();
672 ModelInfo vnfModelInfo = createVnfModelInfo(true);
673 List<Map<String, String>> instanceParams = ImmutableList.of(ImmutableMap.of("vmx_int_net_len", "24",
674 "vre_a_volume_size_0" , "120"));
675 Map<String, String> supplementaryParams = ImmutableMap.of("vre_a_volume_size_0" , "100",
676 "availability_zone_0" , "mtpocdv-kvm-az01");
677 VfModule vfModule = createVfModule("201673MowAvpnVpeBvL..AVPN_vRE_BV..module-1", "56e2b103-637c-4d1a-adc8-3a7f4a6c3240",
678 "72d9d1cd-f46d-447a-abdb-451d6fb05fa8", instanceParams, supplementaryParams,
679 (isUserProvidedNaming ? "vmxnjr001_AVPN_base_vRE_BV_expansion": null), "myVgName", true);
681 String serviceInstanceId = "aa3514e3-5a33-55df-13ab-12abad84e7aa";
682 String vnfInstanceId = "bb3514e3-5a33-55df-13ab-12abad84e7bb";
684 Mockito.reset(aaiClient);
685 mockAaiClientAaiStatusOK();
686 enableAddCloudOwnerOnMsoRequest();
687 when(aaiClient.isNodeTypeExistsByName(eq("vmxnjr001_AVPN_base_vRE_BV_expansion"), eq(ResourceType.VF_MODULE))).thenReturn(false);
689 String expected = IOUtils.toString(this.getClass().getResource(fileName), "UTF-8");
690 final RequestDetailsWrapper<VfModuleInstantiationRequestDetails> result = asyncInstantiationBL.generateVfModuleInstantiationRequest(
691 vfModule, siModelInfo, serviceInstanceId,
692 vnfModelInfo, vnfInstanceId, volumeGroupInstanceId, "pa0916");
693 MsoOperationalEnvironmentTest.assertThatExpectationIsLikeObject(expected, result);
697 public static Object[][] expectedAggregatedParams() {
698 return new Object[][]{
699 {ImmutableMap.of("a", "b", "c", "d"), ImmutableMap.of("e", "f", "g", "h"), ImmutableList.of(ImmutableMap.of("c", "d", "a", "b", "e", "f", "g", "h"))},
700 {ImmutableMap.of("a", "b", "c", "g"), ImmutableMap.of("c", "d", "e", "f"), ImmutableList.of(ImmutableMap.of("a", "b", "c", "d", "e", "f"))},
701 {ImmutableMap.of(), ImmutableMap.of("c", "d", "e", "f"), ImmutableList.of(ImmutableMap.of("c", "d", "e", "f"))},
702 {ImmutableMap.of("a", "b", "c", "g"), ImmutableMap.of(), ImmutableList.of(ImmutableMap.of("a", "b", "c", "g"))},
703 {ImmutableMap.of(), ImmutableMap.of(), ImmutableList.of()},
704 {null, ImmutableMap.of(), ImmutableList.of()},
705 {ImmutableMap.of(), null, ImmutableList.of()},
709 @Test(dataProvider = "expectedAggregatedParams")
710 public void testAggregateInstanceParamsAndSuppFile(Map<String, String> instanceParams, Map<String, String> suppParams, List<VfModuleInstantiationRequestDetails.UserParamMap<String, String>> expected) {
711 List<VfModuleInstantiationRequestDetails.UserParamMap<String, String>> aggParams = ((AsyncInstantiationBusinessLogicImpl)asyncInstantiationBL).aggregateAllInstanceParams(instanceParams, suppParams);
712 assertThat("Aggregated params are not as expected", aggParams, equalTo(expected));
716 public static Object[][] expectedNetworkRequestDetailsParameters() {
717 return new Object[][]{
718 {true, "/payload_jsons/network_instantiation_request.json"},
719 {false, "/payload_jsons/network_instantiation_request_without_instance_name.json"}
723 @Test(dataProvider = "expectedNetworkRequestDetailsParameters")
724 public void createNetworkRequestDetails_detailsAreAsExpected(boolean isUserProvidedNaming, String filePath) throws IOException {
726 final List<Network> networksList = new ArrayList<>(createNetworkList(null, isUserProvidedNaming, true).values());
727 ModelInfo siModelInfo = createServiceModelInfo();
728 String serviceInstanceId = "aa3514e3-5a33-55df-13ab-12abad84e7aa";
730 Mockito.reset(aaiClient);
731 mockAaiClientAaiStatusOK();
732 enableAddCloudOwnerOnMsoRequest();
733 when(aaiClient.isNodeTypeExistsByName(eq(VNF_NAME), eq(ResourceType.L3_NETWORK))).thenReturn(true);
734 when(aaiClient.isNodeTypeExistsByName(eq(VNF_NAME+"_001"), eq(ResourceType.L3_NETWORK))).thenReturn(false);
736 String expected = IOUtils.toString(this.getClass().getResource(filePath), "UTF-8");
737 final RequestDetailsWrapper<NetworkInstantiationRequestDetails> result = asyncInstantiationBL.generateNetworkInstantiationRequest(networksList.get(0), siModelInfo, serviceInstanceId, "pa0916");
738 MsoOperationalEnvironmentTest.assertThatExpectationIsLikeObject(expected, result);
742 public void createInstanceGroupRequestDetails_detailsAreAsExpected() throws IOException {
744 final InstanceGroup instanceGroup = createInstanceGroup(true, Action.Create);
745 ModelInfo siModelInfo = createServiceModelInfo();
746 String serviceInstanceId = "aa3514e3-5a33-55df-13ab-12abad84e7aa";
748 Mockito.reset(aaiClient);
749 mockAaiClientAaiStatusOK();
750 enableAddCloudOwnerOnMsoRequest();
751 when(aaiClient.isNodeTypeExistsByName(eq(VNF_GROUP_NAME), eq(ResourceType.INSTANCE_GROUP))).thenReturn(true);
752 when(aaiClient.isNodeTypeExistsByName(eq(VNF_GROUP_NAME+"_001"), eq(ResourceType.INSTANCE_GROUP))).thenReturn(false);
754 String expected = IOUtils.toString(this.getClass().getResource("/payload_jsons/instance_group_instantiation_request.json"), "UTF-8");
755 final RequestDetailsWrapper<InstanceGroupInstantiationRequestDetails> result = asyncInstantiationBL.generateInstanceGroupInstantiationRequest(instanceGroup, siModelInfo, serviceInstanceId, "az2018");
756 MsoOperationalEnvironmentTest.assertThatExpectationIsLikeObject(expected, result);
760 public void checkIfNullProjectNameSentToMso(){
761 ServiceInstantiation serviceInstantiationPayload = generateMockMacroServiceInstantiationPayload(true,
762 createVnfList(vfModuleInstanceParamsMapWithParamsToRemove, Collections.EMPTY_LIST, false),
765 RequestDetailsWrapper<ServiceInstantiationRequestDetails> result =
766 asyncInstantiationBL.generateMacroServiceInstantiationRequest(null, serviceInstantiationPayload, serviceInstantiationPayload.getInstanceName(), "az2016");
767 JsonNode jsonNode = new ObjectMapper().valueToTree(result.requestDetails);
768 Assert.assertTrue(jsonNode.get("project").isNull());
769 serviceInstantiationPayload = generateMockMacroServiceInstantiationPayload(true,
770 createVnfList(vfModuleInstanceParamsMapWithParamsToRemove, Collections.EMPTY_LIST, false),
772 false,"not null",false);
773 result = asyncInstantiationBL.generateMacroServiceInstantiationRequest(null, serviceInstantiationPayload, serviceInstantiationPayload.getInstanceName(), "az2016");
774 jsonNode = new ObjectMapper().valueToTree(result.requestDetails);
775 Assert.assertTrue(jsonNode.get("project").get("projectName").asText().equalsIgnoreCase("not null"));
782 public void pushBulkJob_macroServiceverifyCreatedDateBehavior_createdDateIsTheSameForAllServicesInSameBulk() {
783 LocalDateTime startTestDate = LocalDateTime.now().withNano(0);
784 final ServiceInstantiation request = generateMockMacroServiceInstantiationPayload(
786 createVnfList(instanceParamsMapWithoutParams, Collections.EMPTY_LIST, true),
787 100, true,PROJECT_NAME, true
790 pushJobAndAssertDates(startTestDate, request);
794 public void whenCreateServiceInfo_thenModelId_isModelVersionId() {
795 ServiceInfo serviceInfo = asyncInstantiationBL.createServiceInfo("userID",
796 generateALaCarteWithVnfsServiceInstantiationPayload(),
800 "myName", ServiceInfo.ServiceAction.INSTANTIATE);
801 assertEquals(SERVICE_MODEL_VERSION_ID, serviceInfo.getServiceModelId());
806 public void pushBulkJob_aLaCarteServiceverifyCreatedDateBehavior_createdDateIsTheSameForAllServicesInSameBulk() {
807 LocalDateTime startTestDate = LocalDateTime.now().withNano(0);
808 final ServiceInstantiation request = generateALaCarteServiceInstantiationPayload();
809 pushJobAndAssertDates(startTestDate, request);
812 protected void pushJobAndAssertDates(LocalDateTime startTestDate, ServiceInstantiation request) {
813 // in "createServiceInstantiationJob()" we will probe the service, with the generated names
814 configureMockitoWithMockedJob();
816 asyncInstantiationBL.pushBulkJob(request, "myUserId");
817 List<ServiceInfo> serviceInfoList = dataAccessService.getList(ServiceInfo.class, getPropsMap());
819 List<Date> creationDates = new ArrayList<>();
820 for (ServiceInfo serviceInfo : serviceInfoList) {
821 creationDates.add(serviceInfo.getCreatedBulkDate());
823 LocalDateTime endTestDate = LocalDateTime.now();
825 //creation date of all services is the same
826 Assert.assertTrue(creationDates.stream().distinct().count() <= 1);
827 LocalDateTime creationDate = fromDate(creationDates.get(0));
828 assertFalse(creationDate.isBefore(startTestDate));
829 assertFalse(creationDate.isAfter(endTestDate));
832 protected void configureMockitoWithMockedJob() {
833 Mockito.reset(jobAdapterMock);
834 final Job job = mock(Job.class);
835 when(job.getStatus()).thenReturn(PENDING);
836 when(jobAdapterMock.createServiceInstantiationJob(any(), any(), any(), any(), any(), any())).thenReturn(job);
840 public static Object[][] msoToJobStatusDataProvider() {
841 return new Object[][]{
842 {"IN_PROGRESS", JobStatus.IN_PROGRESS},
843 {"INPROGRESS", JobStatus.IN_PROGRESS},
844 {"IN ProGREsS", JobStatus.IN_PROGRESS},
845 {"JAMES_HARDEN", JobStatus.IN_PROGRESS},
846 {"FAILED", JobStatus.FAILED},
847 {"COMpleTE", JobStatus.COMPLETED},
848 {"PENDING", JobStatus.IN_PROGRESS},
849 {"Paused", JobStatus.PAUSE},
850 {"Pause", JobStatus.PAUSE},
851 {"PENDING_MANUAL_TASK", JobStatus.PAUSE},
852 {"UNLOCKED", JobStatus.IN_PROGRESS}
856 @Test(dataProvider = "msoToJobStatusDataProvider")
857 public void whenGetStatusFromMso_calcRightJobStatus(String msoStatus, Job.JobStatus expectedJobStatus) {
858 AsyncRequestStatus asyncRequestStatus = asyncRequestStatusResponse(msoStatus);
859 assertThat(asyncInstantiationBL.calcStatus(asyncRequestStatus), equalTo(expectedJobStatus));
862 private void createNewAuditStatus(JobAuditStatus auditStatus)
864 Date createdDate= auditStatus.getCreated();
865 dataAccessService.saveDomainObject(auditStatus, getPropsMap());
866 setDateToStatus(auditStatus.getSource(), auditStatus.getJobStatus(), createdDate);
871 private static final String MSO_ARBITRARY_STATUS = "completed mso status";
874 public static Object[][] auditStatuses(Method test) {
875 return new Object[][]{
878 new String[]{ JobStatus.PENDING.toString(), JobStatus.IN_PROGRESS.toString()}
881 new String[]{ JobStatus.IN_PROGRESS.toString(), MSO_ARBITRARY_STATUS }
887 private void setDateToStatus(SourceStatus source, String status, Date date) {
888 List<JobAuditStatus> jobAuditStatusList = dataAccessService.getList(JobAuditStatus.class, getPropsMap());
889 DaoUtils.tryWithSessionAndTransaction(sessionFactory, session -> {
890 jobAuditStatusList.stream()
891 .filter(auditStatus -> source.equals(auditStatus.getSource()) && status.equals(auditStatus.getJobStatus()))
892 .forEach(auditStatus -> {
893 auditStatus.setCreated(date);
894 session.saveOrUpdate(auditStatus);
901 @Test(dataProvider = "auditStatuses")
902 public void givenSomeAuditStatuses_getStatusesOfSpecificSourceAndJobId_getSortedResultsMatchingToParameters(SourceStatus expectedSource, String [] expectedSortedStatuses){
903 UUID jobUuid = UUID.randomUUID();
904 List<JobAuditStatus> auditStatusList = com.google.common.collect.ImmutableList.of(
905 new JobAuditStatus(jobUuid, IN_PROGRESS.toString(), SourceStatus.VID, toDate(LocalDateTime.now().minusHours(2))),
906 new JobAuditStatus(jobUuid, IN_PROGRESS.toString(), SourceStatus.MSO, UUID.randomUUID(),"",toDate(LocalDateTime.now().minusHours(30))),
907 new JobAuditStatus(jobUuid, MSO_ARBITRARY_STATUS, SourceStatus.MSO, UUID.randomUUID(),"",toDate(LocalDateTime.now().minusHours(3))),
908 new JobAuditStatus(jobUuid, PENDING.toString(), SourceStatus.VID, toDate(LocalDateTime.now().minusHours(3))),
909 new JobAuditStatus(UUID.randomUUID(), PENDING.toString(), SourceStatus.VID, toDate(LocalDateTime.now().minusHours(3))));
910 auditStatusList.forEach((auditStatus) -> createNewAuditStatus(auditStatus));
911 List<JobAuditStatus> statuses = asyncInstantiationBL.getAuditStatuses(jobUuid, expectedSource);
912 List<String> statusesList = statuses.stream().map(status -> status.getJobStatus()).collect(Collectors.toList());
913 Assert.assertTrue(statuses.stream().allMatch(status -> (status.getSource().equals(expectedSource)&& status.getJobId().equals(jobUuid))),"Only statuses of " + expectedSource + " for " + jobUuid + " should be returned. Returned statuses: " + String.join(",", statusesList ));
914 assertThat(statusesList, contains(expectedSortedStatuses));
920 public void addSomeVidStatuses_getThem_verifyGetInsertedWithoutDuplicates(){
921 ImmutableList<JobStatus> statusesToBeInserted = ImmutableList.of(PENDING, IN_PROGRESS, IN_PROGRESS, COMPLETED);
922 UUID jobUuid = UUID.randomUUID();
923 statusesToBeInserted.forEach(status->
925 asyncInstantiationBL.auditVidStatus(jobUuid, status);
927 List<String> statusesFromDB = asyncInstantiationBL.getAuditStatuses(jobUuid, SourceStatus.VID).stream().map(auditStatus -> auditStatus.getJobStatus()).collect(Collectors.toList());
928 List<String> statusesWithoutDuplicates = statusesToBeInserted.stream().distinct().map(x -> x.toString()).collect(Collectors.toList());
929 assertThat(statusesFromDB, is(statusesWithoutDuplicates));
933 public static Object[][] msoAuditStatuses(Method test) {
934 UUID jobUuid = UUID.randomUUID();
935 UUID requestId = UUID.randomUUID();
936 return new Object[][]{
940 new JobAuditStatus(jobUuid, PENDING.toString(), SourceStatus.MSO, null, null),
941 new JobAuditStatus(jobUuid, IN_PROGRESS.toString(), SourceStatus.MSO, requestId, null),
942 new JobAuditStatus(jobUuid, IN_PROGRESS.toString(), SourceStatus.MSO, requestId, null),
943 new JobAuditStatus(jobUuid, IN_PROGRESS.toString(), SourceStatus.MSO, requestId, null),
944 new JobAuditStatus(jobUuid, COMPLETED.toString(), SourceStatus.MSO, requestId, null)),
945 ImmutableList.of(PENDING.toString(), IN_PROGRESS.toString(), COMPLETED.toString()),
946 "All distinct statuses should be without duplicates"
951 new JobAuditStatus(jobUuid, PENDING.toString(), SourceStatus.MSO, null, null),
952 new JobAuditStatus(jobUuid, IN_PROGRESS.toString(), SourceStatus.MSO, requestId, null),
953 new JobAuditStatus(jobUuid, IN_PROGRESS.toString(), SourceStatus.MSO, requestId, "aa"),
954 new JobAuditStatus(jobUuid, IN_PROGRESS.toString(), SourceStatus.MSO, requestId, "aa"),
955 new JobAuditStatus(jobUuid, IN_PROGRESS.toString(), SourceStatus.MSO, UUID.randomUUID(), "aa"),
956 new JobAuditStatus(jobUuid, COMPLETED.toString(), SourceStatus.MSO, requestId, null)),
957 ImmutableList.of(PENDING.toString(), IN_PROGRESS.toString(), IN_PROGRESS.toString(),IN_PROGRESS.toString(), COMPLETED.toString()),
958 "Statuses should be without duplicates only with same requestId and additionalInfo"
964 @Test(dataProvider = "msoAuditStatuses")
965 public void addSomeMsoStatuses_getThem_verifyGetInsertedWithoutDuplicates(UUID jobUuid, ImmutableList<JobAuditStatus> msoStatuses, ImmutableList<String> expectedStatuses, String assertionReason) {
966 msoStatuses.forEach(status -> {
967 asyncInstantiationBL.auditMsoStatus(status.getJobId(), status.getJobStatus(), status.getRequestId() != null ? status.getRequestId().toString() : null, status.getAdditionalInfo());
969 List<String> statusesFromDB = asyncInstantiationBL.getAuditStatuses(jobUuid, SourceStatus.MSO).stream().map(auditStatus -> auditStatus.getJobStatus()).collect(Collectors.toList());
970 assertThat( assertionReason, statusesFromDB, is(expectedStatuses));
974 public void addSameStatusOfVidAndMso_verifyThatBothWereAdded(){
975 UUID jobUuid = UUID.randomUUID();
976 JobStatus sameStatus = IN_PROGRESS;
977 asyncInstantiationBL.auditMsoStatus(jobUuid, sameStatus.toString(),null,null);
978 asyncInstantiationBL.auditVidStatus(jobUuid, sameStatus);
979 List<JobAuditStatus> list = dataAccessService.getList(
980 JobAuditStatus.class,
981 String.format(" where JOB_ID = '%s'", jobUuid),
983 Assert.assertEquals(list.size(),2);
984 assertThat(list,everyItem(hasProperty("jobStatus", is(sameStatus.toString()))));
988 public static Object[][] msoRequestStatusFiles(Method test) {
989 return new Object[][]{
990 {"/responses/mso/orchestrationRequestsServiceInstance.json"},
991 {"/responses/mso/orchestrationRequestsVnf.json"},
992 {"/responses/mso/orchestrationRequestsMockedMinimalResponse.json"}
996 @Test(dataProvider="msoRequestStatusFiles")
997 public void verifyAsyncRequestStatus_canBeReadFromSample(String msoResponseFile) throws IOException {
998 AsyncRequestStatus asyncRequestStatus = TestUtils.readJsonResourceFileAsObject(
1000 AsyncRequestStatus.class);
1001 assertThat(asyncRequestStatus.request.requestStatus.getRequestState(), equalTo("COMPLETE"));
1005 public void deleteJobInfo_pending_deleted() {
1006 doNothing().when(jobsBrokerServiceMock).delete(any());
1007 UUID uuid = createServicesInfoWithDefaultValues(PENDING);
1008 asyncInstantiationBL.deleteJob(uuid);
1009 assertNotNull(asyncInstantiationBL.getServiceInfoByJobId(uuid).getDeletedAt(), "service info wasn't deleted");
1012 @Test(expectedExceptions = IllegalStateException.class, expectedExceptionsMessageRegExp = DELETE_SERVICE_INFO_STATUS_EXCEPTION_MESSAGE)
1013 public void deleteJobInfo_notAllowdStatus_shouldSendError() {
1014 UUID uuid = createServicesInfoWithDefaultValues(COMPLETED);
1015 doThrow(new IllegalStateException(DELETE_SERVICE_INFO_STATUS_EXCEPTION_MESSAGE)).when(jobsBrokerServiceMock).delete(any());
1017 asyncInstantiationBL.deleteJob(uuid);
1018 } catch (Exception e) {
1019 assertNull(asyncInstantiationBL.getServiceInfoByJobId(uuid).getDeletedAt(), "service info shouldn't deleted");
1025 public Object[][] jobStatusesFinal() {
1026 return Arrays.stream(Job.JobStatus.values())
1027 .filter(t -> ImmutableList.of(COMPLETED, FAILED, STOPPED).contains(t))
1028 .map(v -> new Object[]{v}).collect(Collectors.toList()).toArray(new Object[][]{});
1031 @Test(dataProvider = "jobStatusesFinal")
1032 public void whenHideService_theServiceNotReturnedInServiceList(JobStatus jobStatus) {
1033 UUID uuidToHide = createServicesInfoWithDefaultValues(jobStatus);
1034 UUID uuidToShown = createServicesInfoWithDefaultValues(jobStatus);
1035 List<UUID> serviceInfoList = listServicesUUID();
1036 assertThat(serviceInfoList, hasItems(uuidToHide, uuidToShown));
1038 asyncInstantiationBL.hideServiceInfo(uuidToHide);
1039 serviceInfoList = listServicesUUID();
1040 assertThat(serviceInfoList, hasItem(uuidToShown));
1041 assertThat(serviceInfoList, not(hasItem(uuidToHide)));
1045 protected List<UUID> listServicesUUID() {
1046 return asyncInstantiationBL.getAllServicesInfo().stream().map(ServiceInfo::getJobId).collect(Collectors.toList());
1050 public Object[][] jobStatusesNotFinal() {
1051 return Arrays.stream(Job.JobStatus.values())
1052 .filter(t -> ImmutableList.of(PENDING, IN_PROGRESS, PAUSE).contains(t))
1053 .map(v -> new Object[]{v}).collect(Collectors.toList()).toArray(new Object[][]{});
1056 @Test(dataProvider = "jobStatusesNotFinal",
1057 expectedExceptions = OperationNotAllowedException.class,
1058 expectedExceptionsMessageRegExp = "jobId.*Service status does not allow hide service, status = .*")
1059 public void hideServiceInfo_notAllowedStatus_shouldSendError(JobStatus jobStatus) {
1060 UUID uuid = createServicesInfoWithDefaultValues(jobStatus);
1062 asyncInstantiationBL.hideServiceInfo(uuid);
1063 } catch (Exception e) {
1064 assertFalse(asyncInstantiationBL.getServiceInfoByJobId(uuid).isHidden(), "service info shouldn't be hidden");
1070 public void whenUseGetCounterInMultiThreads_EachThreadGetDifferentCounter() throws InterruptedException {
1072 ExecutorService executor = Executors.newFixedThreadPool(SIZE);
1073 List<Callable<Integer>> tasks = IntStream.rangeClosed(0, SIZE)
1074 .mapToObj(x-> ((Callable<Integer>)() -> asyncInstantiationBL.getCounterForName("a")))
1075 .collect(Collectors.toList());
1076 Set<Integer> expectedResults = IntStream.rangeClosed(0, SIZE).boxed().collect(Collectors.toSet());
1077 executor.invokeAll(tasks)
1078 .forEach(future -> {
1080 assertTrue( expectedResults.remove(future.get()), "got unexpected counter");
1082 catch (Exception e) {
1083 throw new RuntimeException(e);
1087 assertThat(expectedResults.size(), is(0));
1091 public void whenUseGetCounterForSameName_numbersReturnedByOrder() {
1093 String name = UUID.randomUUID().toString();
1095 for (int i=0; i<SIZE; i++) {
1096 assertThat(asyncInstantiationBL.getCounterForName(name), is(i));
1101 public void whenNamedInUsedInAai_getNextNumber() {
1102 String name = someCommonStepsAndGetName();
1103 ResourceType type = ResourceType.GENERIC_VNF;
1104 when(aaiClient.isNodeTypeExistsByName(name, type)).thenReturn(true);
1105 when(aaiClient.isNodeTypeExistsByName(name+"_001", type)).thenReturn(false);
1106 assertThat(asyncInstantiationBL.getUniqueName(name, type), equalTo(name+"_001"));
1109 private String someCommonStepsAndGetName() {
1110 mockAaiClientAaiStatusOK();
1111 return UUID.randomUUID().toString();
1114 private void mockAaiClientAaiStatusOK() {
1115 when(aaiClient.isNodeTypeExistsByName(eq(AsyncInstantiationBusinessLogicImpl.NAME_FOR_CHECK_AAI_STATUS), any())).thenReturn(false);
1118 @Test(expectedExceptions=ExceptionWithRequestInfo.class)
1119 public void whenAaiBadResponseCode_throwInvalidAAIResponseException() {
1120 String name = someCommonStepsAndGetName();
1121 ResourceType type = ResourceType.SERVICE_INSTANCE;
1122 when(aaiClient.isNodeTypeExistsByName(name, type)).thenThrow(aaiNodeQueryBadResponseException());
1123 asyncInstantiationBL.getUniqueName(name, type);
1126 @Test(expectedExceptions=MaxRetriesException.class)
1127 public void whenAaiAlwaysReturnNameUsed_throwInvalidAAIResponseException() {
1128 String name = someCommonStepsAndGetName();
1129 ResourceType type = ResourceType.VF_MODULE;
1130 when(aaiClient.isNodeTypeExistsByName(any(), eq(type))).thenReturn(true);
1131 asyncInstantiationBL.setMaxRetriesGettingFreeNameFromAai(10);
1132 asyncInstantiationBL.getUniqueName(name, type);
1136 public void testFormattingOfNameAndCounter() {
1137 AsyncInstantiationBusinessLogicImpl bl = (AsyncInstantiationBusinessLogicImpl) asyncInstantiationBL;
1138 assertThat(bl.formatNameAndCounter("x", 0), equalTo("x"));
1139 assertThat(bl.formatNameAndCounter("x", 3), equalTo("x_003"));
1140 assertThat(bl.formatNameAndCounter("x", 99), equalTo("x_099"));
1141 assertThat(bl.formatNameAndCounter("x", 100), equalTo("x_100"));
1142 assertThat(bl.formatNameAndCounter("x", 1234), equalTo("x_1234"));
1146 public void pushBulkJob_verifyAlacarteFlow_useALaCartServiceInstantiationJobType(){
1147 final ServiceInstantiation request = generateALaCarteServiceInstantiationPayload();
1149 // in "createServiceInstantiationJob()" we will probe the service, with the generated names
1150 configureMockitoWithMockedJob();
1152 ArgumentCaptor<JobType> argumentCaptor = ArgumentCaptor.forClass(JobType.class);
1153 asyncInstantiationBL.pushBulkJob(request, "myUserId");
1154 verify(jobAdapterMock).createServiceInstantiationJob(argumentCaptor.capture(),any(),any(),anyString(), anyString(), anyInt());
1155 assertTrue(argumentCaptor.getValue().equals(JobType.ALaCarteServiceInstantiation));
1159 public void pushBulkJob_verifyMacroFlow_useMacroServiceInstantiationJobType(){
1160 final ServiceInstantiation request = generateMacroMockServiceInstantiationPayload(false, Collections.emptyMap());
1162 // in "createServiceInstantiationJob()" we will probe the service, with the generated names
1163 configureMockitoWithMockedJob();
1165 ArgumentCaptor<JobType> argumentCaptor = ArgumentCaptor.forClass(JobType.class);
1166 asyncInstantiationBL.pushBulkJob(request, "myUserId");
1167 verify(jobAdapterMock).createServiceInstantiationJob(argumentCaptor.capture(),any(),any(),anyString(), anyString(), anyInt());
1168 assertTrue(argumentCaptor.getValue().equals(JobType.MacroServiceInstantiation));
1172 public void generateALaCarteServiceInstantiationRequest_verifyRequestIsAsExpected() throws IOException {
1173 ServiceInstantiation serviceInstantiationPayload = generateALaCarteServiceInstantiationPayload();
1174 final URL resource = this.getClass().getResource("/payload_jsons/bulk_alacarte_service_request.json");
1175 RequestDetailsWrapper<ServiceInstantiationRequestDetails> result =
1176 asyncInstantiationBL.generateALaCarteServiceInstantiationRequest(null, serviceInstantiationPayload, serviceInstantiationPayload.getInstanceName(), "az2016");
1177 String expected = IOUtils.toString(resource, "UTF-8");
1178 MsoOperationalEnvironmentTest.assertThatExpectationIsLikeObject(expected, result);
1182 public void generateALaCarteServiceDeletionRequest_verifyRequestIsAsExpected() throws IOException {
1183 final URL resource = this.getClass().getResource("/payload_jsons/bulk_alacarte_service_deletion_request.json");
1184 String expected = IOUtils.toString(resource, "UTF-8");
1186 ServiceInstantiation serviceDeletionPayload = generateALaCarteServiceDeletionPayload();
1187 RequestDetailsWrapper<ServiceDeletionRequestDetails> result =
1188 asyncInstantiationBL.generateALaCarteServiceDeletionRequest(null, serviceDeletionPayload, "az2016");
1190 MsoOperationalEnvironmentTest.assertThatExpectationIsLikeObject(expected, result);
1194 public void getALaCarteServiceDeletionPath_verifyPathIsAsExpected() throws IOException {
1196 String expected = "/serviceInstantiation/v./serviceInstances/f36f5734-e9df-4fbf-9f35-61be13f028a1";
1198 String result = asyncInstantiationBL.getServiceDeletionPath("f36f5734-e9df-4fbf-9f35-61be13f028a1");
1200 assertThat(result, matchesPattern(expected));
1204 public void getInstanceGroupsDeletionPath_verifyPathIsAsExpected() {
1206 assertEquals(asyncInstantiationBL.getInstanceGroupDeletePath("9aada4af-0f9b-424f-ae21-e693bd3e005b"),
1207 "/serviceInstantiation/v7/instanceGroups/9aada4af-0f9b-424f-ae21-e693bd3e005b");
1211 public static Object[][] testBuildVnfInstanceParamsDataProvider(Method test) {
1212 return new Object[][]{
1214 Collections.EMPTY_LIST,
1216 ImmutableList.of(ImmutableMap.of("k1","v1","k2","v2")),
1217 ImmutableList.of(ImmutableMap.of("k3","v3","k2","v2"))
1220 ImmutableList.of(ImmutableMap.of("k1","v1","k2","v2","k3","v3"))
1223 ImmutableList.of(ImmutableMap.of("j1", "w1", "k1","v1", "vnf_name","w2", "vf_module_name","w3")), //vnf_name, vf_module_name are excluded
1225 ImmutableList.of(ImmutableMap.of("k1","v1","k2","v2")),
1226 ImmutableList.of(ImmutableMap.of("k3","v3","k2","v2")),
1227 ImmutableList.of(Collections.EMPTY_MAP),
1228 Collections.singletonList(null)
1231 ImmutableList.of(ImmutableMap.of("k1","v1","k2","v2","k3","v3","j1", "w1"))
1234 Collections.EMPTY_LIST,
1235 Arrays.asList(null, null),
1237 Collections.EMPTY_LIST //mso is expect to empty list and not list with empty map
1240 ImmutableList.of(Collections.EMPTY_MAP),
1242 ImmutableList.of(Collections.EMPTY_MAP),
1243 ImmutableList.of(Collections.EMPTY_MAP)
1246 Collections.EMPTY_LIST //mso is expect to empty list and not list with empty map
1249 Collections.EMPTY_LIST,
1251 ImmutableList.of(ImmutableMap.of("k1","v1","k2","v2")),
1252 ImmutableList.of(ImmutableMap.of("k3","v3","k2","v2"))
1255 Collections.EMPTY_LIST //mso is expect to empty list and not list with empty map
1258 ImmutableList.of(ImmutableMap.of("j1", "w1", "k1","v1", "vnf_name","w2", "vf_module_name","w3")),
1260 ImmutableList.of(Collections.EMPTY_MAP)
1263 ImmutableList.of(ImmutableMap.of("j1", "w1", "k1","v1"))
1266 ImmutableList.of(ImmutableMap.of("vnf_name","w2", "vf_module_name", "w3", "j2", "w2", "j4","w4")),
1268 ImmutableList.of(ImmutableMap.of("k1","v1","k2","v2")),
1269 ImmutableList.of(ImmutableMap.of("k3","v3","k2","v2"))
1272 ImmutableList.of(ImmutableMap.of("j2", "w2", "j4","w4"))
1278 @Test(dataProvider="testBuildVnfInstanceParamsDataProvider")
1279 public void testBuildVnfInstanceParams(List<Map<String, String>> currentVnfInstanceParams,
1280 List<List<Map<String, String>>> vfModulesInstanceParams,
1281 boolean isFeatureActive,
1282 List<Map<String,String>> expectedResult){
1283 when(featureManager.isActive(Features.FLAG_SHIFT_VFMODULE_PARAMS_TO_VNF)).thenReturn(isFeatureActive);
1284 List<VfModuleMacro> vfModules =
1285 vfModulesInstanceParams.stream().map(params-> new VfModuleMacro(new ModelInfo(), null, null, params)).collect(Collectors.toList());
1286 List<Map<String,String>> actual = asyncInstantiationBL.buildVnfInstanceParams(currentVnfInstanceParams, vfModules);
1287 assertThat(actual, equalTo(expectedResult));
1292 public void whenLcpRegionNotEmpty_thenCloudRegionIdOfResourceIsLegacy() {
1293 String legacyCloudRegion = "legacyCloudRegion";
1294 Vnf vnf = new Vnf(new ModelInfo(), null, null, Action.Create.name(), null, "anyCloudRegion", legacyCloudRegion, null, null, null, false, null, null);
1295 assertThat(vnf.getLcpCloudRegionId(), equalTo(legacyCloudRegion));
1301 public void whenLcpRegionNotEmpty_thenCloudRegionIdOfServiceIsLegacy() {
1302 String legacyCloudRegion = "legacyCloudRegion";
1303 ServiceInstantiation service = new ServiceInstantiation(new ModelInfo(), null, null, null, null, null, null,
1304 null, null, "anyCloudRegion", legacyCloudRegion, null, null, null, null, null, null, null, null,
1305 false, 1,false, false, null, null, Action.Create.name());
1306 assertThat(service.getLcpCloudRegionId(), equalTo(legacyCloudRegion));
1310 public void createVolumeGroup_verifyResultAsExpected() throws IOException {
1311 final URL resource = this.getClass().getResource("/payload_jsons/volumegroup_instantiation_request.json");
1312 VfModule vfModule = createVfModule("201673MowAvpnVpeBvL..AVPN_vRE_BV..module-1",
1313 "56e2b103-637c-4d1a-adc8-3a7f4a6c3240",
1314 "72d9d1cd-f46d-447a-abdb-451d6fb05fa8",
1315 Collections.emptyList(),
1316 Collections.emptyMap(),
1317 "vmxnjr001_AVPN_base_vRE_BV_expansion",
1320 vfModule.getModelInfo().setModelInvariantId("ff5256d2-5a33-55df-13ab-12abad84e7ff");
1321 vfModule.getModelInfo().setModelVersion("1");
1322 ModelInfo vnfModelInfo = createVnfModelInfo(true);
1323 RequestDetailsWrapper<VolumeGroupRequestDetails> result =
1324 asyncInstantiationBL.generateVolumeGroupInstantiationRequest(vfModule,
1325 createServiceModelInfo(),
1326 "ff3514e3-5a33-55df-13ab-12abad84e7ff",
1330 String expected = IOUtils.toString(resource, "UTF-8");
1331 MsoOperationalEnvironmentTest.assertThatExpectationIsLikeObject(expected, result);
1335 public void getJobTypeByRequest_verifyResultAsExpected(){
1336 ServiceInstantiation service = new ServiceInstantiation(new ModelInfo(), null, null, null, null, null, null,
1337 null, null, null, null, null, null, null, null, null, null, null, null,
1338 false, 1,false, false, null, null, Action.Create.name());
1339 JobType jobType = asyncInstantiationBL.getJobType(service) ;
1340 assertThat(jobType, equalTo(JobType.MacroServiceInstantiation));
1341 service = new ServiceInstantiation(new ModelInfo(), null, null, null, null, null, null,
1342 null, null, null, null, null, null, null, null, null, null, null, null,
1343 false, 1,false, true, null, null, Action.Create.name());
1344 jobType = asyncInstantiationBL.getJobType(service);
1345 assertThat(jobType, equalTo(JobType.ALaCarteServiceInstantiation));
1346 service = new ServiceInstantiation(new ModelInfo(), null, null, null, null, null, null,
1347 null, null, null, null, null, null, null, null, null, null, null, null,
1348 false, 1,false, true, null, null, Action.Delete.name());
1349 jobType = asyncInstantiationBL.getJobType(service);
1350 assertThat(jobType, equalTo(JobType.ALaCarteService));
1353 protected ServiceInstantiation generateALaCarteServiceInstantiationPayload() {
1354 return generateMockALaCarteServiceInstantiationPayload(false, Collections.EMPTY_MAP, Collections.EMPTY_MAP, Collections.EMPTY_MAP, 1, true, PROJECT_NAME, false, "VNF_API");
1357 private ServiceInstantiation generateALaCarteServiceDeletionPayload() {
1358 return generateMockALaCarteServiceDeletionPayload(false, Collections.EMPTY_MAP, Collections.EMPTY_MAP, Collections.EMPTY_MAP, 1, true, PROJECT_NAME, false, "VNF_API", "1234567890");
1361 static class MockedJob implements Job {
1363 private static Map<UUID, MockedJob> uuidToJob = new HashMap<>();
1365 public static void putJob(UUID uuid, MockedJob job) {
1366 uuidToJob.put(uuid, job);
1369 public static MockedJob getJob(UUID uuid) {
1370 return uuidToJob.get(uuid);
1374 private String optimisticUniqueServiceInstanceName;
1376 public MockedJob(String optimisticUniqueServiceInstanceName) {
1377 this.optimisticUniqueServiceInstanceName = optimisticUniqueServiceInstanceName;
1380 private UUID uuid = UUID.randomUUID();
1383 public UUID getUuid() {
1388 public void setUuid(UUID uuid) {
1393 public JobStatus getStatus() {
1394 return JobStatus.PENDING;
1398 public void setStatus(JobStatus status) {
1403 public Map<String, Object> getData() {
1408 public JobSharedData getSharedData() {
1409 return new JobSharedData(uuid, "", null);
1413 public void setTypeAndData(JobType jobType, Map<String, Object> commandData) {
1418 public UUID getTemplateId() {
1423 public void setTemplateId(UUID templateId) {
1428 public Integer getIndexInBulk() {
1433 public void setIndexInBulk(Integer indexInBulk) {
1438 public JobType getType() {
1442 public String getOptimisticUniqueServiceInstanceName() {
1443 return optimisticUniqueServiceInstanceName;