1 package org.onap.vid.api;
3 import com.google.common.collect.ImmutableList;
4 import com.google.common.collect.ImmutableSet;
5 import net.bytebuddy.utility.RandomString;
6 import net.javacrumbs.jsonunit.JsonAssert;
7 import org.apache.commons.lang3.builder.ReflectionToStringBuilder;
8 import org.apache.commons.lang3.builder.ToStringStyle;
9 import org.hamcrest.BaseMatcher;
10 import org.hamcrest.CoreMatchers;
11 import org.hamcrest.Description;
12 import org.onap.simulator.presetGenerator.presets.BasePresets.BasePreset;
13 import org.onap.simulator.presetGenerator.presets.aai.PresetAAIGetSubscribersGet;
14 import org.onap.simulator.presetGenerator.presets.aai.PresetAAISearchNodeQueryEmptyResult;
15 import org.onap.simulator.presetGenerator.presets.ecompportal_att.PresetGetSessionSlotCheckIntervalGet;
16 import org.onap.simulator.presetGenerator.presets.mso.*;
17 import org.onap.vid.model.asyncInstantiation.JobAuditStatus;
18 import org.onap.vid.model.asyncInstantiation.ServiceInfo;
19 import org.onap.vid.model.mso.MsoResponseWrapper2;
20 import org.springframework.core.ParameterizedTypeReference;
21 import org.springframework.http.HttpStatus;
22 import org.springframework.http.ResponseEntity;
23 import org.springframework.web.client.HttpClientErrorException;
24 import org.springframework.web.client.RestTemplate;
25 import org.testng.Assert;
26 import org.testng.annotations.DataProvider;
27 import org.testng.annotations.Test;
28 import vid.automation.test.infra.FeatureTogglingTest;
29 import vid.automation.test.infra.Features;
30 import vid.automation.test.infra.Wait;
31 import vid.automation.test.model.JobStatus;
32 import vid.automation.test.services.SimulatorApi;
35 import java.util.function.Predicate;
36 import java.util.stream.Collectors;
37 import java.util.stream.IntStream;
38 import java.util.stream.Stream;
40 import static java.lang.Boolean.FALSE;
41 import static java.lang.Boolean.TRUE;
42 import static java.util.stream.Collectors.*;
43 import static org.hamcrest.CoreMatchers.*;
44 import static org.hamcrest.MatcherAssert.assertThat;
45 import static org.hamcrest.Matchers.hasProperty;
46 import static org.hamcrest.Matchers.hasSize;
47 import static org.onap.simulator.presetGenerator.presets.mso.PresetMSOServiceInstanceGen2WithNames.Keys;
48 import static org.testng.Assert.assertNotNull;
49 import static org.testng.AssertJUnit.assertTrue;
51 @FeatureTogglingTest({Features.FLAG_ASYNC_JOBS, Features.FLAG_ASYNC_INSTANTIATION})
52 public class AsyncInstantiationApiTest extends BaseMsoApiTest {
54 private static final String CREATE_BULK_OF_MACRO_REQUEST = "asyncInstantiation/vidRequestCreateBulkOfMacro.json";
57 public static Object[][] trueAndFalse() {
58 return new Object[][]{{TRUE},{FALSE}};
61 private String getCreateBulkUri() {
62 return uri.toASCIIString() + "/asyncInstantiation/bulk";
65 private String getHideServiceUri(String jobId) {
66 return uri.toASCIIString() + "/asyncInstantiation/hide/"+jobId;
69 private String getServiceInfoUrl() {
70 return uri.toASCIIString() + "/asyncInstantiation";
73 private String getJobAuditUrl() {
74 return uri.toASCIIString() + "/asyncInstantiation/auditStatus/{JOB_ID}?source={SOURCE}";
77 private String getDeleteServiceUrl(String uuid) {
78 return uri.toASCIIString() + "/asyncInstantiation/job/" + uuid;
81 public static class JobIdAndStatusMatcher extends BaseMatcher<ServiceInfo> {
82 private String expectedJobId;
84 public JobIdAndStatusMatcher(String expectedJobId) {
85 this.expectedJobId = expectedJobId;
89 public boolean matches(Object item) {
90 if (!(item instanceof ServiceInfo)) {
93 ServiceInfo serviceInfo = (ServiceInfo) item;
94 return expectedJobId.equals(serviceInfo.jobId);
98 public void describeTo(Description description) {
99 description.appendText("failed to find job with uuid ")
100 .appendValue(expectedJobId);
107 public void createBulkOfCreateInstances(){
108 Map<Keys, String> names = generateNames();
109 final int bulkSize = 3;
110 ImmutableList<BasePreset> presets = addPresetsForCreateBulkOfCreateInstances(bulkSize, names);
111 createBulkOfInstancesAndAssert(presets, false, bulkSize, JobStatus.COMPLETED, names);
114 private Map<Keys,String> generateNames() {
115 return Stream.of(Keys.values()).collect(
116 Collectors.toMap(x->x, x -> UUID.randomUUID().toString().replace("-","")));
119 private ImmutableList<BasePreset> addPresetsForCreateBulkOfCreateInstances(int bulkSize, Map<Keys, String> names){
120 ImmutableList<BasePreset> msoBulkPresets = IntStream.rangeClosed(1,bulkSize).
121 mapToObj(i-> new PresetMSOCreateServiceInstanceGen2WithNames(names, i))
122 .collect(ImmutableList.toImmutableList());
123 ImmutableList<BasePreset> presets = new ImmutableList.Builder<BasePreset>()
124 .add(new PresetGetSessionSlotCheckIntervalGet())
125 .add(new PresetAAIGetSubscribersGet())
126 .add(new PresetAAISearchNodeQueryEmptyResult())
127 .addAll(msoBulkPresets)
128 .add(new PresetMSOOrchestrationRequestGet())
134 private ResponseEntity<List<JobAuditStatus>> auditStatusCall(String url) {
135 return restTemplate.exchange(
137 org.springframework.http.HttpMethod.GET,
139 new ParameterizedTypeReference<List<JobAuditStatus>>() {});
143 public static Object[][] auditSources() {
144 return new Object[][]{{JobAuditStatus.SourceStatus.VID},{JobAuditStatus.SourceStatus.MSO}};
148 @Test(dataProvider = "auditSources")
149 public void getAuditStatus_nonExistingJobId_returnsEmptyList(JobAuditStatus.SourceStatus source){
150 List<JobAuditStatus> audits = getAuditStatuses(UUID.randomUUID().toString(), source.name());
151 Assert.assertEquals(audits.size(),0);
154 @Test(expectedExceptions = HttpClientErrorException.class)
155 public void getAuditStatus_nonExistingSource_returnsError() {
157 getAuditStatuses(UUID.randomUUID().toString(), new RandomString(8).nextString());
158 } catch (HttpClientErrorException e) {
159 Assert.assertEquals(e.getResponseBodyAsString(),"The parameter source must have a value among : MSO, VID");
160 assertThat(e.getStatusCode(), is(HttpStatus.BAD_REQUEST));
166 public void simulateBulkRequest_getAuditStatus_auditStatusesReturnedAccordingSource() {
167 final int bulkSize = 2;
168 final List<String> jobIds = createBulkAndWaitForBeCompleted(bulkSize);
170 for(String jobId: jobIds) {
171 List<JobAuditStatus> actualVidAudits = getAuditStatuses(jobId, JobAuditStatus.SourceStatus.VID.name());
172 List<JobAuditStatus> expectedVidAudits = Stream.of(JobStatus.PENDING, JobStatus.IN_PROGRESS, JobStatus.COMPLETED)
173 .map(status->new JobAuditStatus(UUID.fromString(jobId),
175 JobAuditStatus.SourceStatus.VID,
178 status.equals(JobStatus.COMPLETED))).collect(toList());
179 assertThat(actualVidAudits, is(expectedVidAudits));
181 List<JobAuditStatus> actualMsoAudits = getAuditStatuses(jobId, JobAuditStatus.SourceStatus.MSO.name());
182 List<JobAuditStatus> expectedMsoAudits = Stream.of("REQUESTED", "COMPLETE")
183 .map(status-> new JobAuditStatus(UUID.fromString(jobId),
185 JobAuditStatus.SourceStatus.MSO,
186 UUID.fromString("c0011670-0e1a-4b74-945d-8bf5aede1d9c"),
187 status.equals("COMPLETE") ? "Service Instance was created successfully." : null,
188 false)).collect(toList());
189 assertThat(actualMsoAudits, is(expectedMsoAudits));
193 protected List<String> createBulkAndWaitForBeCompleted(int bulkSize){
194 Map<Keys, String> names = generateNames();
195 ImmutableList<BasePreset> presets = addPresetsForCreateBulkOfCreateInstances(bulkSize, names);
196 final List<String> jobIds = createBulkOfInstances(presets, false, bulkSize, names);
197 Assert.assertEquals(jobIds.size(),bulkSize);
199 assertTrue(String.format("Not all services with ids: %s are in state completed after 30 sec",
200 jobIds.stream().collect(joining(","))),
202 Wait.waitFor(y-> serviceListCall().getBody().stream()
203 .filter(si -> jobIds.contains(si.jobId))
204 .filter(si -> si.jobStatus==JobStatus.COMPLETED)
205 .count() == bulkSize,
210 private List<JobAuditStatus> getAuditStatuses(String jobUUID, String source){
211 String url = getJobAuditUrl().replace("{JOB_ID}",jobUUID).replace("{SOURCE}", source);
212 ResponseEntity<List<JobAuditStatus>> statusesResponse = auditStatusCall(url);
213 assertThat(statusesResponse.getStatusCode(), CoreMatchers.equalTo(HttpStatus.OK));
214 return statusesResponse.getBody();
217 @Test(expectedExceptions = HttpClientErrorException.class)
218 public void addBulkAndDeleteInProgress_deletionIsRejected(){
220 final Map<String, JobStatus> jobs = addBulkAllPendingButOneInProgress();
221 deleteOneJobHavingTheStatus(jobs, JobStatus.IN_PROGRESS);
222 } catch (HttpClientErrorException e) {
223 JsonAssert.assertJsonPartEquals(
224 "Service status does not allow deletion from the queue (Request id: null)",
225 e.getResponseBodyAsString(),
228 assertThat(e.getStatusCode(), is(HttpStatus.METHOD_NOT_ALLOWED));
235 public void addBulkAndDeletePending_deletedIsHiddenFromServiceInfoResults(){
236 Map<String, JobStatus> statusesBefore = addBulkAllPendingButOneInProgress();
238 final String deletedJob = deleteOneJobHavingTheStatus(statusesBefore, JobStatus.PENDING);
240 final Map<String, JobStatus> statusesNow = serviceListCall().getBody().stream()
241 .filter(si -> statusesBefore.keySet().contains(si.jobId))
242 .collect(toMap(si -> si.jobId, si -> si.jobStatus));
244 statusesBefore.remove(deletedJob);
245 assertThat("deleted job shall not be present in StatusInfo response", statusesNow, is(statusesBefore));
248 private Map<String, JobStatus> addBulkAllPendingButOneInProgress(){
249 return addBulkAllPendingButOneInProgress(3);
252 private Map<String, JobStatus> addBulkAllPendingButOneInProgress(int bulkSize){
253 Map<Keys, String> names = generateNames();
254 ImmutableList<BasePreset> msoBulkPresets = IntStream.rangeClosed(1,bulkSize)
255 .mapToObj(i-> new PresetMSOCreateServiceInstanceGen2WithNames(names, i))
256 .collect(ImmutableList.toImmutableList());
257 ImmutableList<BasePreset> presets = new ImmutableList.Builder<BasePreset>()
258 .add(new PresetGetSessionSlotCheckIntervalGet())
259 .add(new PresetAAISearchNodeQueryEmptyResult())
260 .add(new PresetAAIGetSubscribersGet())
261 .addAll(msoBulkPresets)
262 .add(new PresetMSOOrchestrationRequestGet("IN_PROGRESS"))
264 final List<String> jobIds = createBulkOfInstances(presets, false, bulkSize, names);
266 // wait for single IN_PROGRESS, so statuses will stop from changing
267 Wait.waitFor(foo -> serviceListCall().getBody().stream()
268 .filter(si -> jobIds.contains(si.jobId))
269 .anyMatch(si -> si.jobStatus.equals(JobStatus.IN_PROGRESS)),
272 final Map<String, JobStatus> statusMapBefore = serviceListCall().getBody().stream()
273 .filter(si -> jobIds.contains(si.jobId))
274 .collect(toMap(si -> si.jobId, si -> si.jobStatus));
276 assertThat(jobIds, hasSize(bulkSize));
279 return statusMapBefore;
282 private String deleteOneJobHavingTheStatus(Map<String, JobStatus> jobIdToStatus, JobStatus jobStatus) {
283 final String jobToDelete = jobIdToStatus.entrySet().stream()
284 .filter(entry -> entry.getValue().equals(jobStatus))
285 .map(Map.Entry::getKey)
286 .findFirst().orElseThrow(() -> new AssertionError("no job in " + jobStatus + " state: " + jobIdToStatus));
289 restTemplate.delete(getDeleteServiceUrl(jobToDelete));
294 @Test(invocationCount = 3)
295 public void createBulkOfCreateInstancesWithSinglePreset_firstOneInProgressOtherArePending(){
296 final int bulkSize = 3;
297 Map<String, JobStatus> statusMap = addBulkAllPendingButOneInProgress(bulkSize);
298 Set<String> jobIds = statusMap.keySet();
300 final Map<JobStatus, List<ServiceInfo>> statuses = serviceListCall().getBody().stream()
301 .filter(si -> jobIds.contains(si.jobId))
302 .collect(groupingBy(ServiceInfo::getJobStatus));
304 // Variable "statuses" contains two lists by status:
305 // IN_PROGRESS: The ultimate first job - named with _001 - is always the only one in progress
306 // PENDING: The other two jobs - named with _002 and _003 - are the still pending
307 assertThat(jobIds, hasSize(bulkSize));
308 assertThat(statuses.get(JobStatus.IN_PROGRESS), hasSize(1));
309 assertThat(statuses.get(JobStatus.IN_PROGRESS), everyItem(hasProperty("serviceInstanceName", endsWith("_001"))));
311 assertThat(statuses.get(JobStatus.PENDING), hasSize(bulkSize - 1));
315 @Test(dataProvider = "trueAndFalse" )
316 public void whenServiceInBulkFailed_otherServicesAreStopped(Boolean isPresetForCreate){
317 Map<Keys, String> names = generateNames();
318 final int bulkSize = 3;
320 //if there is a preset for create, service shall failed during in_progress (upon get status)
321 //it there is no preset for create, service shall failed during pending (upon create request)
322 List<BasePreset> msoBulkPresets = isPresetForCreate ?
323 IntStream.rangeClosed(1,bulkSize)
324 .mapToObj(i-> new PresetMSOCreateServiceInstanceGen2WithNames(names, i))
325 .collect(ImmutableList.toImmutableList()) :
327 ImmutableList<BasePreset> presets = new ImmutableList.Builder<BasePreset>()
328 .add(new PresetGetSessionSlotCheckIntervalGet())
329 .add(new PresetAAIGetSubscribersGet())
330 .add(new PresetAAISearchNodeQueryEmptyResult())
331 .addAll(msoBulkPresets)
332 .add(new PresetMSOOrchestrationRequestGet("FAILED"))
334 List<String> jobIds = createBulkOfInstances(presets, false, bulkSize, names);
335 Assert.assertEquals(jobIds.size(),bulkSize);
336 boolean result = Wait.waitFor(x->{
337 List<ServiceInfo> serviceInfoList = serviceListCall().getBody();
338 Map<JobStatus, Long> statusCount = serviceInfoList.stream().filter(si->jobIds.contains(si.jobId)).collect(groupingBy(ServiceInfo::getJobStatus, counting()));
339 return Objects.equals(statusCount.get(JobStatus.FAILED), 1L) && Objects.equals(statusCount.get(JobStatus.STOPPED), 2L);
341 assertTrue(String.format("failed to get jobs [%s] to state of: 1 failed and 2 stopped ",
342 String.join(",", jobIds)),result);
346 public void createBulkOfAssignInstances(){
347 Map<Keys, String> names = generateNames();
348 final int bulkSize = 2;
349 ImmutableList<BasePreset> msoBulkPresets = IntStream.rangeClosed(1,bulkSize)
350 .mapToObj(i-> new PresetMSOAssignServiceInstanceGen2WithNames(names, i))
351 .collect(ImmutableList.toImmutableList());
352 ImmutableList<BasePreset> presets = new ImmutableList.Builder<BasePreset>()
353 .add(new PresetGetSessionSlotCheckIntervalGet())
354 .add(new PresetAAIGetSubscribersGet())
355 .add(new PresetAAISearchNodeQueryEmptyResult())
356 .addAll(msoBulkPresets)
357 .add(new PresetMSOOrchestrationRequestGet())
359 createBulkOfInstancesAndAssert(presets, true, bulkSize, JobStatus.COMPLETED, names);
363 public void tryToCreateBulkOfAssignInstancesErrorResponseFromMso(){
364 ImmutableList<BasePreset> presets = ImmutableList.of(
365 new PresetGetSessionSlotCheckIntervalGet(),
366 new PresetAAIGetSubscribersGet(),
367 new PresetAAISearchNodeQueryEmptyResult(),
368 new PresetMSOServiceInstanceGen2ErrorResponse(406));
370 List<String> jobIds = createBulkOfInstancesAndAssert(presets, true,1, JobStatus.FAILED, generateNames());
371 String jobId = jobIds.get(0);
372 List<JobAuditStatus> actualMsoAudits = getAuditStatuses(jobId, JobAuditStatus.SourceStatus.MSO.name());
373 JobAuditStatus expectedMsoAudit = new JobAuditStatus(UUID.fromString(jobId),"FAILED",JobAuditStatus.SourceStatus.MSO,
375 "Http Code:406, \"messageId\":\"SVC0002\",\"text\":\"JSON Object Mapping Request\"" ,
377 assertThat(actualMsoAudits.get(0), is(expectedMsoAudit));
381 public void whenHideCompletedService_thenServiceNotReturnInServiceList(){
382 List<String> services = createBulkAndWaitForBeCompleted(2);
383 hideService(services.get(0));
384 List<String> serviceInfoList = serviceListCall().getBody().stream().map(ServiceInfo::getJobId).collect(toList());
385 assertThat(serviceInfoList, hasItem(services.get(1)));
386 assertThat(serviceInfoList, not(hasItem(services.get(0))));
389 private MsoResponseWrapper2 hideService(String jobId) {
390 MsoResponseWrapper2 responseWrapper2 = callMsoForResponseWrapper(org.springframework.http.HttpMethod.POST, getHideServiceUri(jobId), "");
391 return responseWrapper2;
394 private List<String> createBulkOfInstancesAndAssert(ImmutableList<BasePreset> presets, boolean isPause, int bulkSize, JobStatus finalState, Map<Keys, String> names){
395 List<String> jobIds = createBulkOfInstances(presets, isPause, bulkSize, names);
396 Assert.assertEquals(jobIds.size(),bulkSize);
397 for(String jobId: jobIds) {
398 ServiceInfo expectedServiceInfo = new ServiceInfo("vid1", JobStatus.IN_PROGRESS, isPause, "someID",
399 "someName", "myProject", "NFT1", "NFTJSSSS-NFT1", "greatTenant", "greatTenant", "mtn3", null,
400 "mySubType", "a9a77d5a-123e-4ca2-9eb9-0b015d2ee0fb", null, names.get(Keys.SERVICE_NAME),
401 "300adb1e-9b0c-4d52-bfb5-fa5393c4eabb", "AIM_TRANSPORT_00004", "1.0", jobId, null);
402 JobInfoChecker jobInfoChecker = new JobInfoChecker(
403 restTemplate, ImmutableSet.of(JobStatus.PENDING, JobStatus.IN_PROGRESS, finalState), jobId, expectedServiceInfo);
404 boolean result = jobInfoChecker.test(null);
405 assertTrue("service info of jobId: " + jobId + " was in status: " + jobInfoChecker.lastStatus, result);
407 jobInfoChecker.setExpectedJobStatus(ImmutableSet.of(finalState));
408 if (ImmutableList.of(JobStatus.COMPLETED, JobStatus.PAUSE).contains(finalState)) {
409 expectedServiceInfo.serviceInstanceId = "f8791436-8d55-4fde-b4d5-72dd2cf13cfb";
411 result = Wait.waitFor(jobInfoChecker, null, 20, 1);
412 assertTrue("service info of jobId: " + jobId + " was in status: " + jobInfoChecker.lastStatus, result);
418 private List<String> createBulkOfInstances(ImmutableList<BasePreset> presets, boolean isPause, int bulkSize, Map<Keys, String> names){
420 SimulatorApi.registerExpectationFromPresets(presets, SimulatorApi.RegistrationStrategy.CLEAR_THEN_SET);
422 String requestBody = TestUtils.convertRequest(objectMapper, CREATE_BULK_OF_MACRO_REQUEST);
423 requestBody = requestBody.replace("\"IS_PAUSE_VALUE\"", String.valueOf(isPause)).replace("\"BULK_SIZE\"", String.valueOf(bulkSize));
424 for (Map.Entry<Keys, String> e : names.entrySet()) {
425 requestBody = requestBody.replace(e.getKey().name(), e.getValue());
427 MsoResponseWrapper2 responseWrapper2 = callMsoForResponseWrapper(org.springframework.http.HttpMethod.POST, getCreateBulkUri(), requestBody);
428 assertNotNull(responseWrapper2);
429 return (List<String>)responseWrapper2.getEntity();
432 public class JobInfoChecker<Integer> implements Predicate<Integer> {
434 private final RestTemplate restTemplate;
435 private Set<JobStatus> expectedJobStatus;
436 private ServiceInfo expectedServiceInfo;
437 private final String jobId;
438 private JobStatus lastStatus;
440 public JobInfoChecker(RestTemplate restTemplate, Set<JobStatus> expectedJobStatus, String jobId, ServiceInfo expectedServiceInfo) {
441 this.restTemplate = restTemplate;
442 this.expectedJobStatus = expectedJobStatus;
444 this.expectedServiceInfo = expectedServiceInfo;
447 public void setExpectedJobStatus(Set<JobStatus> expectedJobStatus) {
448 this.expectedJobStatus = expectedJobStatus;
452 public boolean test(Integer integer) {
453 ResponseEntity<List<ServiceInfo>> serviceListResponse = serviceListCall();
454 assertThat(serviceListResponse.getStatusCode(), CoreMatchers.equalTo(HttpStatus.OK));
455 assertThat(serviceListResponse.getBody(), hasItem(new JobIdAndStatusMatcher(jobId)));
456 ServiceInfo serviceInfoFromDB = serviceListResponse.getBody().stream()
457 .filter(serviceInfo -> serviceInfo.jobId.equals(jobId))
458 .findFirst().orElse(null);
459 Assert.assertNotNull(serviceInfoFromDB);
460 Assert.assertEquals(serviceInfoDataReflected(serviceInfoFromDB), serviceInfoDataReflected(expectedServiceInfo));
461 assertTrue("actual service instance doesn't contain template service name:" + expectedServiceInfo.serviceInstanceName,
462 serviceInfoFromDB.serviceInstanceName.contains(expectedServiceInfo.serviceInstanceName));
463 if (serviceInfoFromDB.jobStatus==JobStatus.IN_PROGRESS || serviceInfoFromDB.jobStatus==JobStatus.COMPLETED) {
464 assertTrue("actual service instance doesn't contain template service name and trailing numbers:" + expectedServiceInfo.serviceInstanceName,
465 serviceInfoFromDB.serviceInstanceName.contains(expectedServiceInfo.serviceInstanceName+"_00"));
468 if (expectedServiceInfo.serviceInstanceId != null) {
469 assertThat(serviceInfoFromDB.serviceInstanceId, is(expectedServiceInfo.serviceInstanceId));
471 lastStatus = serviceInfoFromDB.jobStatus;
472 return expectedJobStatus.contains(serviceInfoFromDB.jobStatus);
476 private ResponseEntity<List<ServiceInfo>> serviceListCall() {
477 return restTemplate.exchange(
479 org.springframework.http.HttpMethod.GET,
481 new ParameterizedTypeReference<List<ServiceInfo>>() {});
484 //serialize fields except of fields we cannot know ahead of time
485 private static String serviceInfoDataReflected(ServiceInfo service1) {
486 return new ReflectionToStringBuilder(service1, ToStringStyle.SHORT_PREFIX_STYLE)
487 .setExcludeFieldNames("jobStatus", "templateId", "statusModifiedDate", "createdBulkDate", "serviceInstanceId", "serviceInstanceName")
492 public void errorResponseInGetStatusFromMso_getAuditStatusFromMso_errorMsgExistInAdditionalInfo(){
493 Map<Keys, String> names = generateNames();
494 ImmutableList<BasePreset> presets = new ImmutableList.Builder<BasePreset>()
495 .add(new PresetGetSessionSlotCheckIntervalGet())
496 .add(new PresetAAIGetSubscribersGet())
497 .add(new PresetAAISearchNodeQueryEmptyResult())
498 .add(new PresetMSOAssignServiceInstanceGen2WithNames(names, 1))
499 .add(new PresetMSOOrchestrationRequestGetErrorResponse(406))
502 final List<String> jobIds = createBulkOfInstancesAndAssert(presets, true,1, JobStatus.IN_PROGRESS, names);
503 String jobId = jobIds.get(0);
504 Wait.waitFor(y-> getAuditStatuses(jobId, JobAuditStatus.SourceStatus.MSO.name()).stream()
505 .anyMatch(si -> si.getJobStatus().equals("FAILED")),
507 List<JobAuditStatus> actualMsoAudits = getAuditStatuses(jobId, JobAuditStatus.SourceStatus.MSO.name());
508 List<JobAuditStatus> expectedMsoAudits = Stream.of("REQUESTED", "FAILED")
509 .map(status -> new JobAuditStatus(UUID.fromString(jobId),
511 JobAuditStatus.SourceStatus.MSO,
512 UUID.fromString("c0011670-0e1a-4b74-945d-8bf5aede1d9c"),
513 status.equals("FAILED") ? "Http Code:406, \"messageId\":\"SVC0002\",\"text\":\"JSON Object Mapping Request\"" : null,
514 false)).collect(toList());
515 assertThat(actualMsoAudits, is(expectedMsoAudits));