src/test/java/org/onap/nbi/apis/ApiTest.java

   1 package org.onap.nbi.apis;
   2
   3
   4 import static org.assertj.core.api.Assertions.assertThat;
   5 import java.util.ArrayList;
   6 import java.util.Date;
   7 import java.util.List;
   8 import java.util.Set;
   9 import javax.validation.Validation;
  10 import javax.validation.Validator;
  11 import javax.validation.ValidatorFactory;
  12 import org.junit.After;
  13 import org.junit.AfterClass;
  14 import org.junit.BeforeClass;
  15 import org.junit.Ignore;
  16 import org.junit.Test;
  17 import org.junit.runner.RunWith;
  18 import org.onap.nbi.apis.assertions.ServiceCatalogAssertions;
  19 import org.onap.nbi.apis.assertions.ServiceInventoryAssertions;
  20 import org.onap.nbi.apis.assertions.ServiceOrderAssertions;
  21 import org.onap.nbi.apis.servicecatalog.ServiceSpecificationResource;
  22 import org.onap.nbi.apis.serviceinventory.ServiceInventoryResource;
  23 import org.onap.nbi.apis.serviceorder.ServiceOrderResource;
  24 import org.onap.nbi.apis.serviceorder.model.ActionType;
  25 import org.onap.nbi.apis.serviceorder.model.RelatedParty;
  26 import org.onap.nbi.apis.serviceorder.model.Service;
  27 import org.onap.nbi.apis.serviceorder.model.ServiceOrder;
  28 import org.onap.nbi.apis.serviceorder.model.ServiceOrderItem;
  29 import org.onap.nbi.apis.serviceorder.model.StateType;
  30 import org.onap.nbi.apis.serviceorder.model.orchestrator.ExecutionTask;
  31 import org.onap.nbi.apis.serviceorder.repositories.ExecutionTaskRepository;
  32 import org.onap.nbi.apis.serviceorder.repositories.ServiceOrderInfoRepository;
  33 import org.onap.nbi.apis.serviceorder.repositories.ServiceOrderRepository;
  34 import org.onap.nbi.apis.serviceorder.workflow.SOTaskProcessor;
  35 import org.springframework.beans.factory.annotation.Autowired;
  36 import org.springframework.boot.context.embedded.LocalServerPort;
  37 import org.springframework.boot.test.context.SpringBootTest;
  38 import org.springframework.http.ResponseEntity;
  39 import org.springframework.test.context.junit4.SpringRunner;
  40 import org.springframework.util.LinkedMultiValueMap;
  41 import org.springframework.util.MultiValueMap;
  42 import com.github.tomakehurst.wiremock.WireMockServer;
  43 import com.github.tomakehurst.wiremock.stubbing.ListStubMappingsResult;
  44 import com.github.tomakehurst.wiremock.stubbing.StubMapping;
  45
  46 @RunWith(SpringRunner.class)
  47 @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
  48 public class ApiTest {
  49
  50     @LocalServerPort
  51     int randomServerPort;
  52
  53     String realServerPort;
  54
  55     static public WireMockServer wireMockServer = new WireMockServer(8091);
  56
  57     @Autowired
  58     ServiceSpecificationResource serviceSpecificationResource;
  59
  60     @Autowired
  61     ServiceInventoryResource serviceInventoryResource;
  62
  63     @Autowired
  64     ServiceOrderResource serviceOrderResource;
  65
  66     @Autowired
  67     ServiceOrderRepository serviceOrderRepository;
  68
  69     @Autowired
  70     ServiceOrderInfoRepository serviceOrderInfoRepository;
  71
  72     @Autowired
  73     ExecutionTaskRepository executionTaskRepository;
  74
  75     @Autowired
  76     SOTaskProcessor SoTaskProcessor;
  77
  78     static Validator validator;
  79
  80     @BeforeClass
  81     public static void setUp() throws Exception {
  82         wireMockServer.start();
  83         ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
  84         validator = factory.getValidator();
  85     }
  86
  87     @AfterClass
  88     public static void tearsDown() throws Exception {
  89         wireMockServer.stop();
  90
  91     }
  92
  93     @After
  94     public void tearsDownUpPort() throws Exception {
  95         executionTaskRepository.deleteAll();
  96         serviceOrderInfoRepository.deleteAll();
  97         serviceOrderRepository.deleteAll();
  98         wireMockServer.resetToDefaultMappings();
  99
 100     }
 101
 102
 103     public ExecutionTask getExecutionTask(String orderItemId) {
 104         for (ExecutionTask executionTask : executionTaskRepository.findAll()) {
 105             if (executionTask.getOrderItemId().equalsIgnoreCase(orderItemId)) {
 106                 return executionTask;
 107             }
 108
 109         }
 110         return null;
 111     }
 112
 113     // serviceCatalog
 114
 115     @Test
 116     @Ignore
 117     public void testServiceResourceGetCatalog() throws Exception {
 118
 119         ResponseEntity<Object> resource =
 120                 serviceSpecificationResource.getServiceSpecification("1e3feeb0-8e36-46c6-862c-236d9c626439", null);
 121         ServiceCatalogAssertions.assertGetServiceCatalog(resource);
 122
 123     }
 124
 125     @Test
 126     public void testServiceCatalogGetResourceWithoutTosca() throws Exception {
 127
 128         ResponseEntity<Object> resource = serviceSpecificationResource
 129                 .getServiceSpecification("1e3feeb0-8e36-46c6-862c-236d9c626439_withoutTosca", null);
 130         ServiceCatalogAssertions.asserGetServiceCatalogWithoutTosca(resource);
 131
 132     }
 133
 134     @Test
 135     public void testServiceCatalogFind() throws Exception {
 136
 137         ResponseEntity<Object> resource = serviceSpecificationResource.findServiceSpecification(null);
 138         ServiceCatalogAssertions.assertFindServiceCatalog(resource);
 139
 140     }
 141
 142
 143     @Test
 144     public void testServiceCatalogFindWithFilter() throws Exception {
 145
 146         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 147         params.add("fields", "name");
 148         ResponseEntity<Object> resource = serviceSpecificationResource.findServiceSpecification(params);
 149         ServiceCatalogAssertions.assertFindServiceCatalogWIthFilter(resource);
 150
 151     }
 152
 153     // serviceInventory
 154
 155     @Test
 156     public void testServiceResourceGetInventory() throws Exception {
 157
 158         String serviceName = "vFW";
 159         String serviceId = "e4688e5f-61a0-4f8b-ae02-a2fbde623bcb";
 160         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 161         params.add("serviceSpecification.name", serviceName);
 162         params.add("relatedParty.id", "6490");
 163         ResponseEntity<Object> resource = serviceInventoryResource.getServiceInventory(serviceId, params);
 164         ServiceInventoryAssertions.assertServiceInventoryGet(resource);
 165
 166     }
 167
 168
 169     @Test
 170     public void testServiceResourceGetInventoryWithServiceSpecId() throws Exception {
 171
 172         String serviceId = "e4688e5f-61a0-4f8b-ae02-a2fbde623bcb";
 173         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 174         params.add("serviceSpecification.id", "1e3feeb0-8e36-46c6-862c-236d9c626439");
 175         params.add("relatedParty.id", "6490");
 176         ResponseEntity<Object> resource = serviceInventoryResource.getServiceInventory(serviceId, params);
 177         ServiceInventoryAssertions.assertServiceInventoryGet(resource);
 178
 179     }
 180
 181
 182     @Test
 183     public void testServiceInventoryFind() throws Exception {
 184
 185         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 186         String serviceName = "vFW";
 187         params.add("serviceSpecification.name", serviceName);
 188         params.add("relatedParty.id", "6490");
 189
 190         ResponseEntity<Object> resource = serviceInventoryResource.findServiceInventory(params);
 191         ServiceInventoryAssertions.assertServiceInventoryFind(resource);
 192
 193     }
 194
 195
 196     @Test
 197     public void testServiceInventoryFindWithServiceSpecId() throws Exception {
 198
 199         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 200         params.add("serviceSpecification.id", "1e3feeb0-8e36-46c6-862c-236d9c626439");
 201         params.add("relatedParty.id", "6490");
 202
 203         ResponseEntity<Object> resource = serviceInventoryResource.findServiceInventory(params);
 204         ServiceInventoryAssertions.assertServiceInventoryFind(resource);
 205
 206     }
 207
 208
 209     @Test
 210     public void testServiceInventoryFindWithoutParameter() throws Exception {
 211
 212         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 213         params.add("relatedParty.id", "6490");
 214
 215         ResponseEntity<Object> resource = serviceInventoryResource.findServiceInventory(params);
 216         ServiceInventoryAssertions.assertServiceInventoryFindWithoutParameter(resource);
 217
 218     }
 219
 220     @Test
 221     public void testCreateServiceOrderResource() throws Exception {
 222
 223         ResponseEntity<Object> serviceOrder = serviceOrderResource
 224                 .createServiceOrder(ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD), null, null);
 225         assertThat(serviceOrder.getStatusCodeValue()).isEqualTo(201);
 226         ServiceOrder body = (ServiceOrder) serviceOrder.getBody();
 227         assertThat(body.getId()).isNotNull();
 228         assertThat(body.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 229
 230
 231     }
 232
 233     @Test
 234     public void testCheckServiceOrder() throws Exception {
 235
 236         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 237         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 238         testServiceOrder.setId("test");
 239         serviceOrderRepository.save(testServiceOrder);
 240
 241         serviceOrderResource.scheduleCheckServiceOrders();
 242
 243         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 244         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 245
 246     }
 247
 248     @Test
 249     public void testCheckServiceOrderWithGenericCustomer() throws Exception {
 250
 251         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 252         testServiceOrder.setRelatedParty(new ArrayList<>());
 253         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 254         testServiceOrder.setId("test");
 255         serviceOrderRepository.save(testServiceOrder);
 256
 257         serviceOrderResource.scheduleCheckServiceOrders();
 258
 259         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 260         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 261
 262     }
 263
 264     @Test
 265     public void testCheckServiceOrderWithUnKnonwCustomer() throws Exception {
 266
 267         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 268         List<RelatedParty> customers = new ArrayList<>();
 269         RelatedParty customer = new RelatedParty();
 270         customer.setId("new");
 271         customer.setRole("ONAPcustomer");
 272         customer.setName("romain");
 273         customers.add(customer);
 274         testServiceOrder.setRelatedParty(customers);
 275         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 276         testServiceOrder.setId("test");
 277         serviceOrderRepository.save(testServiceOrder);
 278
 279         serviceOrderResource.scheduleCheckServiceOrders();
 280
 281         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 282         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 283
 284     }
 285
 286     @Test
 287     public void testCheckServiceOrderDelete() throws Exception {
 288
 289         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 290         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 291         testServiceOrder.setId("test");
 292         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 293             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 294         }
 295         serviceOrderRepository.save(testServiceOrder);
 296
 297         serviceOrderResource.scheduleCheckServiceOrders();
 298
 299         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 300         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 301
 302     }
 303
 304     @Test
 305     public void testCheckServiceOrderDeleteRejected() throws Exception {
 306
 307         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 308         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 309             serviceOrderItem.getService().setId("no_response");
 310
 311         }
 312         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 313         testServiceOrder.setId("test");
 314         serviceOrderRepository.save(testServiceOrder);
 315
 316         serviceOrderResource.scheduleCheckServiceOrders();
 317
 318         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 319         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
 320
 321     }
 322
 323     @Test
 324     public void testCheckServiceOrderNoChange() throws Exception {
 325
 326         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 327         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 328             serviceOrderItem.setAction(ActionType.NOCHANGE);
 329         }
 330
 331         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 332         testServiceOrder.setId("test");
 333         serviceOrderRepository.save(testServiceOrder);
 334
 335         serviceOrderResource.scheduleCheckServiceOrders();
 336
 337         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 338         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 339         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 340             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 341         }
 342
 343     }
 344
 345
 346
 347     @Test
 348     public void testCheckServiceOrderNoChangeAndDelete() throws Exception {
 349
 350         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 351         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 352             if (serviceOrderItem.getId().equals("A")) {
 353                 serviceOrderItem.setAction(ActionType.NOCHANGE);
 354             }
 355             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 356         }
 357
 358         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 359         testServiceOrder.setId("test");
 360         serviceOrderRepository.save(testServiceOrder);
 361
 362         serviceOrderResource.scheduleCheckServiceOrders();
 363
 364         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 365         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 366         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 367             if (serviceOrderItem.getId().equals("A"))
 368                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 369         }
 370     }
 371
 372
 373
 374     @Test
 375     public void testCheckServiceOrderRejected() throws Exception {
 376
 377
 378         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrderRejected();
 379         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 380         testServiceOrder.setId("test");
 381         serviceOrderRepository.save(testServiceOrder);
 382
 383         serviceOrderResource.scheduleCheckServiceOrders();
 384
 385         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 386         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
 387
 388     }
 389
 390     @Test
 391     public void validateServiceOrderBeanWithAnnotation() {
 392         ServiceOrder serviceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 393         Set violations = validator.validate(serviceOrder);
 394         assertThat(violations).isEmpty();
 395
 396         ServiceOrderItem item = new ServiceOrderItem();
 397         item.setAction(ActionType.DELETE);
 398         item.setService(new Service());
 399         serviceOrder.addOrderItemItem(item);
 400
 401         violations = validator.validate(serviceOrder);
 402         assertThat(violations).isNotEmpty();
 403     }
 404
 405
 406
 407     @Test
 408     public void testFindAndGetServiceOrder() throws Exception {
 409
 410         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 411         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 412             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 413         }
 414         testServiceOrder.setExternalId("extid1");
 415         testServiceOrder.setOrderDate(new Date());
 416         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 417         testServiceOrder.setDescription("toto");
 418         testServiceOrder.setId("test");
 419         serviceOrderRepository.save(testServiceOrder);
 420
 421
 422         ServiceOrder testServiceOrder2 = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 423         testServiceOrder2.setState(StateType.ACKNOWLEDGED);
 424         testServiceOrder2.setDescription("toto");
 425         testServiceOrder2.setId("test2");
 426         testServiceOrder2.setExternalId("extid2");
 427         testServiceOrder2.setOrderDate(new Date());
 428
 429         serviceOrderRepository.save(testServiceOrder2);
 430
 431
 432         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 433         params.add("fields", "id");
 434
 435         ResponseEntity<Object> serviceOrdersResponse = serviceOrderResource.findServiceOrder(params);
 436         ArrayList serviceOrders = (ArrayList) serviceOrdersResponse.getBody();
 437         assertThat(serviceOrders.size()).isEqualTo(2);
 438
 439         params.add("externalId", "extid1");
 440         params.add("state", "acknowledged");
 441
 442         serviceOrdersResponse = serviceOrderResource.findServiceOrder(params);
 443         serviceOrders = (ArrayList) serviceOrdersResponse.getBody();
 444         assertThat(serviceOrders.size()).isEqualTo(1);
 445
 446         MultiValueMap<String, String> paramsDate = new LinkedMultiValueMap<>();
 447         paramsDate.add("orderDate.gt", "2017-01-01 00:00:00.000");
 448         paramsDate.add("orderDate.lt", "2030-01-01 00:00:00.000");
 449         paramsDate.add("offset", "0");
 450         paramsDate.add("limit", "2");
 451
 452         serviceOrdersResponse = serviceOrderResource.findServiceOrder(paramsDate);
 453         serviceOrders = (ArrayList) serviceOrdersResponse.getBody();
 454         assertThat(serviceOrders.size()).isEqualTo(2);
 455
 456
 457         ResponseEntity<Object> serviceOrderResponse =
 458                 serviceOrderResource.getServiceOrder("test2", new LinkedMultiValueMap<>());
 459         ServiceOrder serviceOrder = (ServiceOrder) serviceOrderResponse.getBody();
 460         assertThat(serviceOrder).isNotNull();
 461     }
 462
 463
 464
 465     @Test
 466     public void testExecutionTaskSuccess() throws Exception {
 467
 468         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 469                 serviceOrderInfoRepository, executionTaskRepository, ActionType.ADD);
 470         ExecutionTask executionTaskB;
 471
 472
 473         SoTaskProcessor.processOrderItem(executionTaskA);
 474         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 475         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 476         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 477             if (serviceOrderItem.getId().equals("A")) {
 478                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 479             } else {
 480                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 481             }
 482         }
 483
 484         executionTaskB = getExecutionTask("B");
 485         assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 486         executionTaskA = getExecutionTask("A");
 487         assertThat(executionTaskA).isNull();
 488
 489         SoTaskProcessor.processOrderItem(executionTaskB);
 490         serviceOrderChecked = serviceOrderRepository.findOne("test");
 491         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 492         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 493             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 494
 495         }
 496
 497         executionTaskB = getExecutionTask("B");
 498         assertThat(executionTaskB).isNull();
 499
 500
 501     }
 502
 503
 504     @Test
 505     public void testExecutionTaskDeleteSuccess() throws Exception {
 506
 507         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 508                 serviceOrderInfoRepository, executionTaskRepository, ActionType.DELETE);
 509         ExecutionTask executionTaskB;
 510
 511
 512         SoTaskProcessor.processOrderItem(executionTaskA);
 513         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 514         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 515         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 516             if (serviceOrderItem.getId().equals("A")) {
 517                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 518             } else {
 519                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 520             }
 521         }
 522
 523         executionTaskB = getExecutionTask("B");
 524         assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 525         executionTaskA = getExecutionTask("A");
 526         assertThat(executionTaskA).isNull();
 527
 528         SoTaskProcessor.processOrderItem(executionTaskB);
 529         serviceOrderChecked = serviceOrderRepository.findOne("test");
 530         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 531         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 532             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 533
 534         }
 535
 536         executionTaskB = getExecutionTask("B");
 537         assertThat(executionTaskB).isNull();
 538
 539
 540     }
 541
 542
 543     @Test
 544     public void testExecutionTaskFailed() throws Exception {
 545
 546         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 547                 serviceOrderInfoRepository, executionTaskRepository, ActionType.ADD);
 548
 549         ListStubMappingsResult listStubMappingsResult = wireMockServer.listAllStubMappings();
 550         StubMapping mappingToDelete = null;
 551         List<StubMapping> mappings = listStubMappingsResult.getMappings();
 552         for (StubMapping mapping : mappings) {
 553             if (mapping.getRequest().getUrl().equals("/ecomp/mso/infra/orchestrationRequests/v4/requestId")) {
 554                 mappingToDelete = mapping;
 555             }
 556         }
 557         wireMockServer.removeStubMapping(mappingToDelete);
 558
 559
 560         SoTaskProcessor.processOrderItem(executionTaskA);
 561         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 562         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 563         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 564             if (serviceOrderItem.getId().equals("A")) {
 565                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS);
 566             } else {
 567                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 568             }
 569         }
 570         executionTaskA = getExecutionTask("A");
 571         assertThat(executionTaskA.getNbRetries()).isEqualTo(2);
 572         SoTaskProcessor.processOrderItem(executionTaskA);
 573         executionTaskA = getExecutionTask("A");
 574         SoTaskProcessor.processOrderItem(executionTaskA);
 575         executionTaskA = getExecutionTask("A");
 576         SoTaskProcessor.processOrderItem(executionTaskA);
 577
 578         serviceOrderChecked = serviceOrderRepository.findOne("test");
 579         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
 580         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 581             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 582
 583         }
 584
 585         ExecutionTask executionTaskB = executionTaskRepository.findOne(Long.parseLong("2"));
 586         assertThat(executionTaskB).isNull();
 587
 588
 589     }
 590
 591 }