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     @Test
 184     public void testServiceResourceGetInventoryWithoutRelationShipList() throws Exception {
 185
 186         String serviceName = "vFW";
 187         String serviceId = "e4688e5f-61a0-4f8b-ae02-a2fbde623bcbWithoutList";
 188         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 189         params.add("serviceSpecification.name", serviceName);
 190         params.add("relatedParty.id", "6490");
 191         ResponseEntity<Object> resource = serviceInventoryResource.getServiceInventory(serviceId, params);
 192         ServiceInventoryAssertions.assertServiceInventoryGetWithoutList(resource);
 193
 194     }
 195
 196
 197     @Test
 198     public void testServiceResourceGetInventoryWithServiceSpecId() throws Exception {
 199
 200         String serviceId = "e4688e5f-61a0-4f8b-ae02-a2fbde623bcb";
 201         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 202         params.add("serviceSpecification.id", "1e3feeb0-8e36-46c6-862c-236d9c626439");
 203         params.add("relatedParty.id", "6490");
 204         ResponseEntity<Object> resource = serviceInventoryResource.getServiceInventory(serviceId, params);
 205         ServiceInventoryAssertions.assertServiceInventoryGet(resource);
 206
 207     }
 208
 209
 210     @Test
 211     public void testServiceInventoryFind() throws Exception {
 212
 213         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 214         String serviceName = "vFW";
 215         params.add("serviceSpecification.name", serviceName);
 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 testServiceInventoryFindWithServiceSpecId() throws Exception {
 226
 227         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 228         params.add("serviceSpecification.id", "1e3feeb0-8e36-46c6-862c-236d9c626439");
 229         params.add("relatedParty.id", "6490");
 230
 231         ResponseEntity<Object> resource = serviceInventoryResource.findServiceInventory(params);
 232         ServiceInventoryAssertions.assertServiceInventoryFind(resource);
 233
 234     }
 235
 236
 237     @Test
 238     public void testServiceInventoryFindWithoutParameter() throws Exception {
 239
 240         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 241         params.add("relatedParty.id", "6490");
 242
 243         ResponseEntity<Object> resource = serviceInventoryResource.findServiceInventory(params);
 244         ServiceInventoryAssertions.assertServiceInventoryFindWithoutParameter(resource);
 245
 246     }
 247
 248     @Test
 249     public void testCreateServiceOrderResource() throws Exception {
 250
 251         ResponseEntity<Object> serviceOrder = serviceOrderResource
 252                 .createServiceOrder(ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD), null, null);
 253         assertThat(serviceOrder.getStatusCodeValue()).isEqualTo(201);
 254         ServiceOrder body = (ServiceOrder) serviceOrder.getBody();
 255         assertThat(body.getId()).isNotNull();
 256         assertThat(body.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 257
 258
 259     }
 260
 261     @Test
 262     public void testCheckServiceOrder() throws Exception {
 263
 264         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 265         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 266         testServiceOrder.setId("test");
 267         serviceOrderRepository.save(testServiceOrder);
 268
 269         serviceOrderResource.scheduleCheckServiceOrders();
 270
 271         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 272         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 273
 274     }
 275
 276     @Test
 277     public void testCheckServiceOrderWithGenericCustomer() throws Exception {
 278
 279         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 280         testServiceOrder.setRelatedParty(new ArrayList<>());
 281         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 282         testServiceOrder.setId("test");
 283         serviceOrderRepository.save(testServiceOrder);
 284
 285         serviceOrderResource.scheduleCheckServiceOrders();
 286
 287         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 288         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 289
 290     }
 291
 292     @Test
 293     public void testCheckServiceOrderWithUnKnonwCustomer() throws Exception {
 294
 295         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 296         List<RelatedParty> customers = new ArrayList<>();
 297         RelatedParty customer = new RelatedParty();
 298         customer.setId("new");
 299         customer.setRole("ONAPcustomer");
 300         customer.setName("romain");
 301         customers.add(customer);
 302         testServiceOrder.setRelatedParty(customers);
 303         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 304         testServiceOrder.setId("test");
 305         serviceOrderRepository.save(testServiceOrder);
 306
 307         serviceOrderResource.scheduleCheckServiceOrders();
 308
 309         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 310         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 311
 312     }
 313
 314     @Test
 315     public void testCheckServiceOrderDelete() throws Exception {
 316
 317         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 318         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 319         testServiceOrder.setId("test");
 320         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 321             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 322         }
 323         serviceOrderRepository.save(testServiceOrder);
 324
 325         serviceOrderResource.scheduleCheckServiceOrders();
 326
 327         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 328         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 329
 330     }
 331
 332     @Test
 333     public void testCheckServiceOrderDeleteRejected() throws Exception {
 334
 335         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 336         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 337             serviceOrderItem.getService().setId("no_response");
 338
 339         }
 340         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 341         testServiceOrder.setId("test");
 342         serviceOrderRepository.save(testServiceOrder);
 343
 344         serviceOrderResource.scheduleCheckServiceOrders();
 345
 346         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 347         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
 348
 349     }
 350
 351     @Test
 352     public void testCheckServiceOrderNoChange() throws Exception {
 353
 354         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 355         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 356             serviceOrderItem.setAction(ActionType.NOCHANGE);
 357         }
 358
 359         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 360         testServiceOrder.setId("test");
 361         serviceOrderRepository.save(testServiceOrder);
 362
 363         serviceOrderResource.scheduleCheckServiceOrders();
 364
 365         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 366         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 367         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 368             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 369         }
 370
 371     }
 372
 373
 374
 375     @Test
 376     public void testCheckServiceOrderNoChangeAndDelete() throws Exception {
 377
 378         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 379         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 380             if (serviceOrderItem.getId().equals("A")) {
 381                 serviceOrderItem.setAction(ActionType.NOCHANGE);
 382             }
 383             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 384         }
 385
 386         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 387         testServiceOrder.setId("test");
 388         serviceOrderRepository.save(testServiceOrder);
 389
 390         serviceOrderResource.scheduleCheckServiceOrders();
 391
 392         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 393         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 394         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 395             if (serviceOrderItem.getId().equals("A"))
 396                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 397         }
 398     }
 399
 400
 401
 402     @Test
 403     public void testCheckServiceOrderRejected() throws Exception {
 404
 405
 406         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrderRejected();
 407         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 408         testServiceOrder.setId("test");
 409         serviceOrderRepository.save(testServiceOrder);
 410
 411         serviceOrderResource.scheduleCheckServiceOrders();
 412
 413         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 414         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
 415
 416     }
 417
 418     @Test
 419     public void validateServiceOrderBeanWithAnnotation() {
 420         ServiceOrder serviceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 421         Set violations = validator.validate(serviceOrder);
 422         assertThat(violations).isEmpty();
 423
 424         ServiceOrderItem item = new ServiceOrderItem();
 425         item.setAction(ActionType.DELETE);
 426         item.setService(new Service());
 427         serviceOrder.addOrderItemItem(item);
 428
 429         violations = validator.validate(serviceOrder);
 430         assertThat(violations).isNotEmpty();
 431     }
 432
 433
 434
 435     @Test
 436     public void testFindAndGetServiceOrder() throws Exception {
 437
 438         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 439         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 440             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 441         }
 442         testServiceOrder.setExternalId("extid1");
 443         testServiceOrder.setOrderDate(new Date());
 444         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 445         testServiceOrder.setDescription("toto");
 446         testServiceOrder.setId("test");
 447         serviceOrderRepository.save(testServiceOrder);
 448
 449
 450         ServiceOrder testServiceOrder2 = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 451         testServiceOrder2.setState(StateType.ACKNOWLEDGED);
 452         testServiceOrder2.setDescription("toto");
 453         testServiceOrder2.setId("test2");
 454         testServiceOrder2.setExternalId("extid2");
 455         testServiceOrder2.setOrderDate(new Date());
 456
 457         serviceOrderRepository.save(testServiceOrder2);
 458
 459
 460         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 461         params.add("fields", "id");
 462
 463         ResponseEntity<Object> serviceOrdersResponse = serviceOrderResource.findServiceOrder(params);
 464         ArrayList serviceOrders = (ArrayList) serviceOrdersResponse.getBody();
 465         assertThat(serviceOrders.size()).isEqualTo(2);
 466
 467         params.add("externalId", "extid1");
 468         params.add("state", "acknowledged");
 469
 470         serviceOrdersResponse = serviceOrderResource.findServiceOrder(params);
 471         serviceOrders = (ArrayList) serviceOrdersResponse.getBody();
 472         assertThat(serviceOrders.size()).isEqualTo(1);
 473
 474         MultiValueMap<String, String> paramsDate = new LinkedMultiValueMap<>();
 475         paramsDate.add("orderDate.gt", "2017-01-01 00:00:00.000");
 476         paramsDate.add("orderDate.lt", "2030-01-01 00:00:00.000");
 477         paramsDate.add("offset", "0");
 478         paramsDate.add("limit", "2");
 479
 480         serviceOrdersResponse = serviceOrderResource.findServiceOrder(paramsDate);
 481         serviceOrders = (ArrayList) serviceOrdersResponse.getBody();
 482         assertThat(serviceOrders.size()).isEqualTo(2);
 483
 484
 485         ResponseEntity<Object> serviceOrderResponse =
 486                 serviceOrderResource.getServiceOrder("test2", new LinkedMultiValueMap<>());
 487         ServiceOrder serviceOrder = (ServiceOrder) serviceOrderResponse.getBody();
 488         assertThat(serviceOrder).isNotNull();
 489     }
 490
 491
 492
 493     @Test
 494     public void testExecutionTaskSuccess() throws Exception {
 495
 496         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 497                 serviceOrderInfoRepository, executionTaskRepository, ActionType.ADD);
 498         ExecutionTask executionTaskB;
 499
 500
 501         SoTaskProcessor.processOrderItem(executionTaskA);
 502         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 503         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 504         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 505             if (serviceOrderItem.getId().equals("A")) {
 506                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 507             } else {
 508                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 509             }
 510         }
 511
 512         executionTaskB = getExecutionTask("B");
 513         assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 514         executionTaskA = getExecutionTask("A");
 515         assertThat(executionTaskA).isNull();
 516
 517         SoTaskProcessor.processOrderItem(executionTaskB);
 518         serviceOrderChecked = serviceOrderRepository.findOne("test");
 519         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 520         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 521             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 522
 523         }
 524
 525         executionTaskB = getExecutionTask("B");
 526         assertThat(executionTaskB).isNull();
 527
 528
 529     }
 530
 531
 532     @Test
 533     public void testExecutionTaskDeleteSuccess() throws Exception {
 534
 535         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 536                 serviceOrderInfoRepository, executionTaskRepository, ActionType.DELETE);
 537         ExecutionTask executionTaskB;
 538
 539
 540         SoTaskProcessor.processOrderItem(executionTaskA);
 541         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 542         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 543         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 544             if (serviceOrderItem.getId().equals("A")) {
 545                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 546             } else {
 547                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 548             }
 549         }
 550
 551         executionTaskB = getExecutionTask("B");
 552         assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 553         executionTaskA = getExecutionTask("A");
 554         assertThat(executionTaskA).isNull();
 555
 556         SoTaskProcessor.processOrderItem(executionTaskB);
 557         serviceOrderChecked = serviceOrderRepository.findOne("test");
 558         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 559         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 560             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 561
 562         }
 563
 564         executionTaskB = getExecutionTask("B");
 565         assertThat(executionTaskB).isNull();
 566
 567
 568     }
 569
 570
 571     @Test
 572     public void testExecutionTaskFailed() throws Exception {
 573
 574         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 575                 serviceOrderInfoRepository, executionTaskRepository, ActionType.ADD);
 576
 577         ListStubMappingsResult listStubMappingsResult = wireMockServer.listAllStubMappings();
 578         StubMapping mappingToDelete = null;
 579         List<StubMapping> mappings = listStubMappingsResult.getMappings();
 580         for (StubMapping mapping : mappings) {
 581             if (mapping.getRequest().getUrl().equals("/ecomp/mso/infra/orchestrationRequests/v4/requestId")) {
 582                 mappingToDelete = mapping;
 583             }
 584         }
 585         wireMockServer.removeStubMapping(mappingToDelete);
 586
 587
 588         SoTaskProcessor.processOrderItem(executionTaskA);
 589         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 590         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 591         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 592             if (serviceOrderItem.getId().equals("A")) {
 593                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS);
 594             } else {
 595                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 596             }
 597         }
 598         executionTaskA = getExecutionTask("A");
 599         assertThat(executionTaskA.getNbRetries()).isEqualTo(2);
 600         SoTaskProcessor.processOrderItem(executionTaskA);
 601         executionTaskA = getExecutionTask("A");
 602         SoTaskProcessor.processOrderItem(executionTaskA);
 603         executionTaskA = getExecutionTask("A");
 604         SoTaskProcessor.processOrderItem(executionTaskA);
 605
 606         serviceOrderChecked = serviceOrderRepository.findOne("test");
 607         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
 608         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 609             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 610
 611         }
 612
 613         ExecutionTask executionTaskB = executionTaskRepository.findOne(Long.parseLong("2"));
 614         assertThat(executionTaskB).isNull();
 615
 616
 617     }
 618
 619 }