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
 293     @Test
 294     public void testCheckServiceOrderWithoutRelatedParty() throws Exception {
 295
 296         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 297         testServiceOrder.setRelatedParty(null);
 298         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 299         testServiceOrder.setId("test");
 300         serviceOrderRepository.save(testServiceOrder);
 301
 302         serviceOrderResource.scheduleCheckServiceOrders();
 303
 304         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 305         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 306
 307
 308     }
 309
 310     @Test
 311     public void testCheckServiceOrderWithUnKnonwCustomer() throws Exception {
 312
 313         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 314         List<RelatedParty> customers = new ArrayList<>();
 315         RelatedParty customer = new RelatedParty();
 316         customer.setId("new");
 317         customer.setRole("ONAPcustomer");
 318         customer.setName("romain");
 319         customers.add(customer);
 320         testServiceOrder.setRelatedParty(customers);
 321         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 322         testServiceOrder.setId("test");
 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 testCheckServiceOrderDelete() throws Exception {
 334
 335         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 336         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 337         testServiceOrder.setId("test");
 338         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 339             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 340         }
 341         serviceOrderRepository.save(testServiceOrder);
 342
 343         serviceOrderResource.scheduleCheckServiceOrders();
 344
 345         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 346         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 347
 348     }
 349
 350     @Test
 351     public void testCheckServiceOrderDeleteRejected() throws Exception {
 352
 353         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 354         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 355             serviceOrderItem.getService().setId("no_response");
 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.REJECTED);
 366
 367     }
 368
 369     @Test
 370     public void testCheckServiceOrderNoChange() throws Exception {
 371
 372         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 373         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 374             serviceOrderItem.setAction(ActionType.NOCHANGE);
 375         }
 376
 377         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 378         testServiceOrder.setId("test");
 379         serviceOrderRepository.save(testServiceOrder);
 380
 381         serviceOrderResource.scheduleCheckServiceOrders();
 382
 383         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 384         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 385         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 386             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 387         }
 388
 389     }
 390
 391
 392
 393     @Test
 394     public void testCheckServiceOrderNoChangeAndDelete() throws Exception {
 395
 396         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 397         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 398             if (serviceOrderItem.getId().equals("A")) {
 399                 serviceOrderItem.setAction(ActionType.NOCHANGE);
 400             }
 401             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 402         }
 403
 404         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 405         testServiceOrder.setId("test");
 406         serviceOrderRepository.save(testServiceOrder);
 407
 408         serviceOrderResource.scheduleCheckServiceOrders();
 409
 410         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 411         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 412         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 413             if (serviceOrderItem.getId().equals("A"))
 414                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 415         }
 416     }
 417
 418
 419
 420     @Test
 421     public void testCheckServiceOrderRejected() throws Exception {
 422
 423
 424         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrderRejected();
 425         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 426         testServiceOrder.setId("test");
 427         serviceOrderRepository.save(testServiceOrder);
 428
 429         serviceOrderResource.scheduleCheckServiceOrders();
 430
 431         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 432         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
 433
 434     }
 435
 436     @Test
 437     public void validateServiceOrderBeanWithAnnotation() {
 438         ServiceOrder serviceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 439         Set violations = validator.validate(serviceOrder);
 440         assertThat(violations).isEmpty();
 441
 442         ServiceOrderItem item = new ServiceOrderItem();
 443         item.setAction(ActionType.DELETE);
 444         item.setService(new Service());
 445         serviceOrder.addOrderItemItem(item);
 446
 447         violations = validator.validate(serviceOrder);
 448         assertThat(violations).isNotEmpty();
 449     }
 450
 451
 452
 453     @Test
 454     public void testFindAndGetServiceOrder() throws Exception {
 455
 456         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 457         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 458             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 459         }
 460         testServiceOrder.setExternalId("extid1");
 461         testServiceOrder.setOrderDate(new Date());
 462         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 463         testServiceOrder.setDescription("toto");
 464         testServiceOrder.setId("test");
 465         serviceOrderRepository.save(testServiceOrder);
 466
 467
 468         ServiceOrder testServiceOrder2 = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 469         testServiceOrder2.setState(StateType.ACKNOWLEDGED);
 470         testServiceOrder2.setDescription("toto");
 471         testServiceOrder2.setId("test2");
 472         testServiceOrder2.setExternalId("extid2");
 473         testServiceOrder2.setOrderDate(new Date());
 474
 475         serviceOrderRepository.save(testServiceOrder2);
 476
 477
 478         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 479         params.add("fields", "id");
 480
 481         ResponseEntity<Object> serviceOrdersResponse = serviceOrderResource.findServiceOrder(params);
 482         ArrayList serviceOrders = (ArrayList) serviceOrdersResponse.getBody();
 483         assertThat(serviceOrders.size()).isEqualTo(2);
 484
 485         params.add("externalId", "extid1");
 486         params.add("state", "acknowledged");
 487
 488         serviceOrdersResponse = serviceOrderResource.findServiceOrder(params);
 489         serviceOrders = (ArrayList) serviceOrdersResponse.getBody();
 490         assertThat(serviceOrders.size()).isEqualTo(1);
 491
 492         MultiValueMap<String, String> paramsDate = new LinkedMultiValueMap<>();
 493         paramsDate.add("orderDate.gt", "2017-01-01 00:00:00.000");
 494         paramsDate.add("orderDate.lt", "2030-01-01 00:00:00.000");
 495         paramsDate.add("offset", "0");
 496         paramsDate.add("limit", "2");
 497
 498         serviceOrdersResponse = serviceOrderResource.findServiceOrder(paramsDate);
 499         serviceOrders = (ArrayList) serviceOrdersResponse.getBody();
 500         assertThat(serviceOrders.size()).isEqualTo(2);
 501
 502
 503         ResponseEntity<Object> serviceOrderResponse =
 504                 serviceOrderResource.getServiceOrder("test2", new LinkedMultiValueMap<>());
 505         ServiceOrder serviceOrder = (ServiceOrder) serviceOrderResponse.getBody();
 506         assertThat(serviceOrder).isNotNull();
 507     }
 508
 509
 510
 511     @Test
 512     public void testExecutionTaskSuccess() throws Exception {
 513
 514         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 515                 serviceOrderInfoRepository, executionTaskRepository, ActionType.ADD);
 516         ExecutionTask executionTaskB;
 517
 518
 519         SoTaskProcessor.processOrderItem(executionTaskA);
 520         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 521         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 522         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 523             if (serviceOrderItem.getId().equals("A")) {
 524                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 525             } else {
 526                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 527             }
 528         }
 529
 530         executionTaskB = getExecutionTask("B");
 531         assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 532         executionTaskA = getExecutionTask("A");
 533         assertThat(executionTaskA).isNull();
 534
 535         SoTaskProcessor.processOrderItem(executionTaskB);
 536         serviceOrderChecked = serviceOrderRepository.findOne("test");
 537         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 538         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 539             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 540
 541         }
 542
 543         executionTaskB = getExecutionTask("B");
 544         assertThat(executionTaskB).isNull();
 545
 546
 547     }
 548
 549
 550     @Test
 551     public void testExecutionTaskDeleteSuccess() throws Exception {
 552
 553         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 554                 serviceOrderInfoRepository, executionTaskRepository, ActionType.DELETE);
 555         ExecutionTask executionTaskB;
 556
 557
 558         SoTaskProcessor.processOrderItem(executionTaskA);
 559         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 560         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 561         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 562             if (serviceOrderItem.getId().equals("A")) {
 563                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 564             } else {
 565                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 566             }
 567         }
 568
 569         executionTaskB = getExecutionTask("B");
 570         assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 571         executionTaskA = getExecutionTask("A");
 572         assertThat(executionTaskA).isNull();
 573
 574         SoTaskProcessor.processOrderItem(executionTaskB);
 575         serviceOrderChecked = serviceOrderRepository.findOne("test");
 576         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 577         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 578             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 579
 580         }
 581
 582         executionTaskB = getExecutionTask("B");
 583         assertThat(executionTaskB).isNull();
 584
 585
 586     }
 587
 588
 589     @Test
 590     public void testExecutionTaskFailed() throws Exception {
 591
 592         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 593                 serviceOrderInfoRepository, executionTaskRepository, ActionType.ADD);
 594
 595         ListStubMappingsResult listStubMappingsResult = wireMockServer.listAllStubMappings();
 596         StubMapping mappingToDelete = null;
 597         List<StubMapping> mappings = listStubMappingsResult.getMappings();
 598         for (StubMapping mapping : mappings) {
 599             if (mapping.getRequest().getUrl().equals("/ecomp/mso/infra/orchestrationRequests/v4/requestId")) {
 600                 mappingToDelete = mapping;
 601             }
 602         }
 603         wireMockServer.removeStubMapping(mappingToDelete);
 604
 605
 606         SoTaskProcessor.processOrderItem(executionTaskA);
 607         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 608         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 609         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 610             if (serviceOrderItem.getId().equals("A")) {
 611                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS);
 612             } else {
 613                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 614             }
 615         }
 616         executionTaskA = getExecutionTask("A");
 617         assertThat(executionTaskA.getNbRetries()).isEqualTo(2);
 618         SoTaskProcessor.processOrderItem(executionTaskA);
 619         executionTaskA = getExecutionTask("A");
 620         SoTaskProcessor.processOrderItem(executionTaskA);
 621         executionTaskA = getExecutionTask("A");
 622         SoTaskProcessor.processOrderItem(executionTaskA);
 623
 624         serviceOrderChecked = serviceOrderRepository.findOne("test");
 625         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
 626         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 627             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 628
 629         }
 630
 631         ExecutionTask executionTaskB = executionTaskRepository.findOne(Long.parseLong("2"));
 632         assertThat(executionTaskB).isNull();
 633
 634
 635     }
 636
 637 }