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

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