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

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