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.ServiceOrderRepository;
  48 import org.onap.nbi.apis.serviceorder.workflow.SOTaskProcessor;
  49 import org.springframework.beans.factory.annotation.Autowired;
  50 import org.springframework.boot.context.embedded.LocalServerPort;
  51 import org.springframework.boot.test.context.SpringBootTest;
  52 import org.springframework.http.ResponseEntity;
  53 import org.springframework.test.context.junit4.SpringRunner;
  54 import org.springframework.util.LinkedMultiValueMap;
  55 import org.springframework.util.MultiValueMap;
  56 import com.github.tomakehurst.wiremock.WireMockServer;
  57 import com.github.tomakehurst.wiremock.stubbing.ListStubMappingsResult;
  58 import com.github.tomakehurst.wiremock.stubbing.StubMapping;
  59
  60 @RunWith(SpringRunner.class)
  61 @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
  62 public class ApiTest {
  63
  64     @LocalServerPort
  65     int randomServerPort;
  66
  67     String realServerPort;
  68
  69     static public WireMockServer wireMockServer = new WireMockServer(8091);
  70
  71     @Autowired
  72     ServiceSpecificationResource serviceSpecificationResource;
  73
  74     @Autowired
  75     ServiceInventoryResource serviceInventoryResource;
  76
  77     @Autowired
  78     ServiceOrderResource serviceOrderResource;
  79
  80     @Autowired
  81     ServiceOrderRepository serviceOrderRepository;
  82
  83     @Autowired
  84     ExecutionTaskRepository executionTaskRepository;
  85
  86     @Autowired
  87     SOTaskProcessor SoTaskProcessor;
  88
  89     static Validator validator;
  90
  91     @BeforeClass
  92     public static void setUp() throws Exception {
  93         wireMockServer.start();
  94         ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
  95         validator = factory.getValidator();
  96     }
  97
  98     @AfterClass
  99     public static void tearsDown() throws Exception {
 100         wireMockServer.stop();
 101
 102     }
 103
 104     @After
 105     public void tearsDownUpPort() throws Exception {
 106         executionTaskRepository.deleteAll();
 107         serviceOrderRepository.deleteAll();
 108         wireMockServer.resetToDefaultMappings();
 109
 110     }
 111
 112
 113     public ExecutionTask getExecutionTask(String orderItemId) {
 114         for (ExecutionTask executionTask : executionTaskRepository.findAll()) {
 115             if (executionTask.getOrderItemId().equalsIgnoreCase(orderItemId)) {
 116                 return executionTask;
 117             }
 118
 119         }
 120         return null;
 121     }
 122
 123     private void removeWireMockMapping(String s) {
 124         ListStubMappingsResult listStubMappingsResult = wireMockServer.listAllStubMappings();
 125         StubMapping mappingToDelete = null;
 126         List<StubMapping> mappings = listStubMappingsResult.getMappings();
 127         for (StubMapping mapping : mappings) {
 128             if (mapping.getRequest().getUrl().equals(s)) {
 129                 mappingToDelete = mapping;
 130             }
 131         }
 132         wireMockServer.removeStubMapping(mappingToDelete);
 133     }
 134
 135     // serviceCatalog
 136
 137
 138     @Test
 139     @Ignore
 140     public void testServiceResourceGetCatalog() throws Exception {
 141
 142         ResponseEntity<Object> resource =
 143             serviceSpecificationResource.getServiceSpecification("1e3feeb0-8e36-46c6-862c-236d9c626439", null);
 144         ServiceCatalogAssertions.assertGetServiceCatalog(resource);
 145
 146     }
 147
 148     @Test
 149     public void testServiceCatalogGetResourceWithoutTosca() throws Exception {
 150
 151         ResponseEntity<Object> resource = serviceSpecificationResource
 152             .getServiceSpecification("1e3feeb0-8e36-46c6-862c-236d9c626439_withoutTosca", null);
 153         ServiceCatalogAssertions.assertGetServiceCatalogWithoutTosca(resource);
 154
 155     }
 156
 157     @Test
 158     public void testServiceCatalogFind() throws Exception {
 159
 160         ResponseEntity<Object> resource = serviceSpecificationResource.findServiceSpecification(null);
 161         ServiceCatalogAssertions.assertFindServiceCatalog(resource);
 162
 163     }
 164
 165
 166     @Test
 167     public void testServiceCatalogFindWithFilter() throws Exception {
 168
 169         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 170         params.add("fields", "name");
 171         ResponseEntity<Object> resource = serviceSpecificationResource.findServiceSpecification(params);
 172         ServiceCatalogAssertions.assertFindServiceCatalogWIthFilter(resource);
 173
 174     }
 175
 176     // serviceInventory
 177
 178     @Test
 179     public void testServiceResourceGetInventory() throws Exception {
 180
 181         String serviceName = "vFW";
 182         String serviceId = "e4688e5f-61a0-4f8b-ae02-a2fbde623bcb";
 183         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 184         params.add("serviceSpecification.name", serviceName);
 185         params.add("relatedParty.id", "6490");
 186         ResponseEntity<Object> resource = serviceInventoryResource.getServiceInventory(serviceId, params);
 187         ServiceInventoryAssertions.assertServiceInventoryGet(resource);
 188
 189     }
 190
 191     @Test
 192     public void testServiceResourceGetInventoryWithoutRelationShipList() throws Exception {
 193
 194         String serviceName = "vFW";
 195         String serviceId = "e4688e5f-61a0-4f8b-ae02-a2fbde623bcbWithoutList";
 196         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 197         params.add("serviceSpecification.name", serviceName);
 198         params.add("relatedParty.id", "6490");
 199         ResponseEntity<Object> resource = serviceInventoryResource.getServiceInventory(serviceId, params);
 200         ServiceInventoryAssertions.assertServiceInventoryGetWithoutList(resource);
 201
 202     }
 203
 204
 205     @Test
 206     public void testServiceResourceGetInventoryWithServiceSpecId() throws Exception {
 207
 208         String serviceId = "e4688e5f-61a0-4f8b-ae02-a2fbde623bcb";
 209         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 210         params.add("serviceSpecification.id", "1e3feeb0-8e36-46c6-862c-236d9c626439");
 211         params.add("relatedParty.id", "6490");
 212         ResponseEntity<Object> resource = serviceInventoryResource.getServiceInventory(serviceId, params);
 213         ServiceInventoryAssertions.assertServiceInventoryGet(resource);
 214
 215     }
 216
 217
 218     @Test
 219     public void testServiceInventoryFind() throws Exception {
 220
 221         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 222         String serviceName = "vFW";
 223         params.add("serviceSpecification.name", serviceName);
 224         params.add("relatedParty.id", "6490");
 225
 226         ResponseEntity<Object> resource = serviceInventoryResource.findServiceInventory(params);
 227         ServiceInventoryAssertions.assertServiceInventoryFind(resource);
 228
 229     }
 230
 231
 232     @Test
 233     public void testServiceInventoryFindWithServiceSpecId() throws Exception {
 234
 235         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 236         params.add("serviceSpecification.id", "1e3feeb0-8e36-46c6-862c-236d9c626439");
 237         params.add("relatedParty.id", "6490");
 238
 239         ResponseEntity<Object> resource = serviceInventoryResource.findServiceInventory(params);
 240         ServiceInventoryAssertions.assertServiceInventoryFind(resource);
 241
 242     }
 243
 244
 245     @Test
 246     public void testServiceInventoryFindWithoutParameter() throws Exception {
 247
 248         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 249         params.add("relatedParty.id", "6490");
 250
 251         ResponseEntity<Object> resource = serviceInventoryResource.findServiceInventory(params);
 252         ServiceInventoryAssertions.assertServiceInventoryFindWithoutParameter(resource);
 253
 254     }
 255
 256     @Test
 257     public void testCreateServiceOrderResource() throws Exception {
 258
 259         ResponseEntity<Object> serviceOrder = serviceOrderResource
 260                 .createServiceOrder(ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD), null, null);
 261         assertThat(serviceOrder.getStatusCodeValue()).isEqualTo(201);
 262         ServiceOrder body = (ServiceOrder) serviceOrder.getBody();
 263         assertThat(body.getId()).isNotNull();
 264         assertThat(body.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 265
 266
 267     }
 268
 269     @Test
 270     public void testCheckServiceOrder() throws Exception {
 271
 272         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 273         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 274         testServiceOrder.setId("test");
 275         serviceOrderRepository.save(testServiceOrder);
 276
 277         serviceOrderResource.scheduleCheckServiceOrders();
 278
 279         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 280         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 281
 282     }
 283
 284     @Test
 285     public void testCheckServiceOrderWithGenericCustomer() throws Exception {
 286
 287         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 288         testServiceOrder.setRelatedParty(new ArrayList<>());
 289         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 290         testServiceOrder.setId("test");
 291         serviceOrderRepository.save(testServiceOrder);
 292
 293         serviceOrderResource.scheduleCheckServiceOrders();
 294
 295         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 296         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 297
 298     }
 299
 300
 301     @Test
 302     public void testCheckServiceOrderWithoutRelatedParty() throws Exception {
 303
 304         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 305         testServiceOrder.setRelatedParty(null);
 306         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 307         testServiceOrder.setId("test");
 308         serviceOrderRepository.save(testServiceOrder);
 309
 310         serviceOrderResource.scheduleCheckServiceOrders();
 311
 312         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 313         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 314
 315
 316     }
 317
 318     @Test
 319     public void testCheckServiceOrderWithUnKnownCustomer() throws Exception {
 320
 321         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 322         List<RelatedParty> customers = new ArrayList<>();
 323         RelatedParty customer = new RelatedParty();
 324         customer.setId("new");
 325         customer.setRole("ONAPcustomer");
 326         customer.setName("romain");
 327         customers.add(customer);
 328         testServiceOrder.setRelatedParty(customers);
 329         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 330         testServiceOrder.setId("test");
 331         serviceOrderRepository.save(testServiceOrder);
 332
 333         serviceOrderResource.scheduleCheckServiceOrders();
 334
 335         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 336         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 337
 338     }
 339
 340
 341     @Test
 342     public void testCheckServiceOrderWithCustomerAAINotResponding() throws Exception {
 343
 344         removeWireMockMapping("/aai/v11/business/customers/customer/new");
 345
 346         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 347         List<RelatedParty> customers = new ArrayList<>();
 348         RelatedParty customer = new RelatedParty();
 349         customer.setId("new");
 350         customer.setRole("ONAPcustomer");
 351         customer.setName("romain");
 352         customers.add(customer);
 353         testServiceOrder.setRelatedParty(customers);
 354         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 355         testServiceOrder.setId("test");
 356         serviceOrderRepository.save(testServiceOrder);
 357
 358         serviceOrderResource.scheduleCheckServiceOrders();
 359
 360         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 361         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
 362
 363     }
 364
 365
 366     @Test
 367     public void testCheckServiceOrderWithPutServiceAAINotResponding() throws Exception {
 368
 369         removeWireMockMapping("/aai/v11/business/customers/customer/new/service-subscriptions/service-subscription/vFW");
 370
 371         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 372         List<RelatedParty> customers = new ArrayList<>();
 373         RelatedParty customer = new RelatedParty();
 374         customer.setId("new");
 375         customer.setRole("ONAPcustomer");
 376         customer.setName("romain");
 377         customers.add(customer);
 378         testServiceOrder.setRelatedParty(customers);
 379         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 380         testServiceOrder.setId("test");
 381         serviceOrderRepository.save(testServiceOrder);
 382
 383         serviceOrderResource.scheduleCheckServiceOrders();
 384
 385         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 386         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
 387
 388     }
 389
 390
 391     @Test
 392     public void testCheckServiceOrderDelete() throws Exception {
 393
 394         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 395         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 396         testServiceOrder.setId("test");
 397         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 398             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 399         }
 400         serviceOrderRepository.save(testServiceOrder);
 401
 402         serviceOrderResource.scheduleCheckServiceOrders();
 403
 404         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 405         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 406
 407     }
 408
 409     @Test
 410     public void testCheckServiceOrderDeleteRejected() throws Exception {
 411
 412         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 413         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 414             serviceOrderItem.getService().setId("no_response");
 415
 416         }
 417         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 418         testServiceOrder.setId("test");
 419         serviceOrderRepository.save(testServiceOrder);
 420
 421         serviceOrderResource.scheduleCheckServiceOrders();
 422
 423         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 424         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
 425
 426     }
 427
 428     @Test
 429     public void testCheckServiceOrderNoChange() throws Exception {
 430
 431         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 432         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 433             serviceOrderItem.setAction(ActionType.NOCHANGE);
 434         }
 435
 436         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 437         testServiceOrder.setId("test");
 438         serviceOrderRepository.save(testServiceOrder);
 439
 440         serviceOrderResource.scheduleCheckServiceOrders();
 441
 442         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 443         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 444         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 445             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 446         }
 447
 448     }
 449
 450
 451
 452     @Test
 453     public void testCheckServiceOrderNoChangeAndDelete() throws Exception {
 454
 455         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 456         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 457             if (serviceOrderItem.getId().equals("A")) {
 458                 serviceOrderItem.setAction(ActionType.NOCHANGE);
 459             }
 460             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 461         }
 462
 463         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 464         testServiceOrder.setId("test");
 465         serviceOrderRepository.save(testServiceOrder);
 466
 467         serviceOrderResource.scheduleCheckServiceOrders();
 468
 469         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 470         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 471         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 472             if (serviceOrderItem.getId().equals("A"))
 473                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 474         }
 475     }
 476
 477
 478     @Test
 479     public void testCheckServiceOrderDeleteWithKoServiceSpecId() throws Exception {
 480
 481         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 482         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 483           serviceOrderItem.getService().getServiceSpecification().setId("undefined");
 484         }
 485
 486         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 487         testServiceOrder.setId("test");
 488         serviceOrderRepository.save(testServiceOrder);
 489
 490         serviceOrderResource.scheduleCheckServiceOrders();
 491
 492         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 493         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
 494         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 495             if (serviceOrderItem.getId().equals("A"))
 496                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.REJECTED);
 497         }
 498     }
 499
 500
 501
 502
 503     @Test
 504     public void testCheckServiceOrderRejected() throws Exception {
 505
 506
 507         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrderRejected();
 508         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 509         testServiceOrder.setId("test");
 510         serviceOrderRepository.save(testServiceOrder);
 511
 512         serviceOrderResource.scheduleCheckServiceOrders();
 513
 514         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 515         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
 516
 517     }
 518
 519     @Test
 520     public void validateServiceOrderBeanWithAnnotation() {
 521         ServiceOrder serviceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 522         Set violations = validator.validate(serviceOrder);
 523         assertThat(violations).isEmpty();
 524
 525         ServiceOrderItem item = new ServiceOrderItem();
 526         item.setAction(ActionType.DELETE);
 527         item.setService(new Service());
 528         serviceOrder.addOrderItemItem(item);
 529
 530         violations = validator.validate(serviceOrder);
 531         assertThat(violations).isNotEmpty();
 532     }
 533
 534
 535
 536     @Test
 537     public void testFindAndGetServiceOrder() throws Exception {
 538
 539         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 540         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 541             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 542         }
 543         testServiceOrder.setExternalId("extid1");
 544         testServiceOrder.setOrderDate(new Date());
 545         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 546         testServiceOrder.setDescription("toto");
 547         testServiceOrder.setId("test");
 548         serviceOrderRepository.save(testServiceOrder);
 549
 550
 551         ServiceOrder testServiceOrder2 = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 552         testServiceOrder2.setState(StateType.ACKNOWLEDGED);
 553         testServiceOrder2.setDescription("toto");
 554         testServiceOrder2.setId("test2");
 555         testServiceOrder2.setExternalId("extid2");
 556         testServiceOrder2.setOrderDate(new Date());
 557
 558         serviceOrderRepository.save(testServiceOrder2);
 559
 560
 561         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 562         params.add("fields", "id");
 563
 564         ResponseEntity<Object> serviceOrdersResponse = serviceOrderResource.findServiceOrder(params);
 565         ArrayList serviceOrders = (ArrayList) serviceOrdersResponse.getBody();
 566         assertThat(serviceOrders.size()).isEqualTo(2);
 567
 568         params.add("externalId", "extid1");
 569         params.add("state", "acknowledged");
 570
 571         serviceOrdersResponse = serviceOrderResource.findServiceOrder(params);
 572         serviceOrders = (ArrayList) serviceOrdersResponse.getBody();
 573         assertThat(serviceOrders.size()).isEqualTo(1);
 574
 575         MultiValueMap<String, String> paramsDate = new LinkedMultiValueMap<>();
 576         paramsDate.add("orderDate.gt", "2017-01-01T00:00:00.000Z");
 577         paramsDate.add("orderDate.lt", "2030-01-01T00:00:00.000Z");
 578         paramsDate.add("offset", "0");
 579         paramsDate.add("limit", "2");
 580
 581         serviceOrdersResponse = serviceOrderResource.findServiceOrder(paramsDate);
 582         serviceOrders = (ArrayList) serviceOrdersResponse.getBody();
 583         assertThat(serviceOrders.size()).isEqualTo(2);
 584
 585
 586         ResponseEntity<Object> serviceOrderResponse =
 587                 serviceOrderResource.getServiceOrder("test2", new LinkedMultiValueMap<>());
 588         ServiceOrder serviceOrder = (ServiceOrder) serviceOrderResponse.getBody();
 589         assertThat(serviceOrder).isNotNull();
 590     }
 591
 592
 593
 594     @Test
 595     public void testExecutionTaskSuccess() throws Exception {
 596
 597         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 598             executionTaskRepository, ActionType.ADD);
 599         ExecutionTask executionTaskB;
 600
 601
 602         SoTaskProcessor.processOrderItem(executionTaskA);
 603         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 604         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 605         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 606             if (serviceOrderItem.getId().equals("A")) {
 607                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 608             } else {
 609                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 610             }
 611         }
 612
 613         executionTaskB = getExecutionTask("B");
 614         assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 615         executionTaskA = getExecutionTask("A");
 616         assertThat(executionTaskA).isNull();
 617
 618         SoTaskProcessor.processOrderItem(executionTaskB);
 619         serviceOrderChecked = serviceOrderRepository.findOne("test");
 620         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 621         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 622             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 623
 624         }
 625
 626         assertThat(executionTaskRepository.count()).isEqualTo(0);
 627
 628
 629
 630     }
 631
 632
 633     @Test
 634     public void testExecutionTaskDeleteSuccess() throws Exception {
 635
 636         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 637             executionTaskRepository, ActionType.DELETE);
 638         ExecutionTask executionTaskB;
 639
 640
 641         SoTaskProcessor.processOrderItem(executionTaskA);
 642         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 643         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 644         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 645             if (serviceOrderItem.getId().equals("A")) {
 646                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 647             } else {
 648                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 649             }
 650         }
 651
 652         executionTaskB = getExecutionTask("B");
 653         assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 654         executionTaskA = getExecutionTask("A");
 655         assertThat(executionTaskA).isNull();
 656
 657         SoTaskProcessor.processOrderItem(executionTaskB);
 658         serviceOrderChecked = serviceOrderRepository.findOne("test");
 659         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 660         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 661             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 662
 663         }
 664
 665         assertThat(executionTaskRepository.count()).isEqualTo(0);
 666
 667
 668
 669     }
 670
 671
 672     @Test
 673     public void testExecutionTaskFailed() throws Exception {
 674
 675         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 676             executionTaskRepository, ActionType.ADD);
 677
 678         removeWireMockMapping("/ecomp/mso/infra/orchestrationRequests/v6/requestId");
 679
 680
 681         SoTaskProcessor.processOrderItem(executionTaskA);
 682         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 683         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 684         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 685             if (serviceOrderItem.getId().equals("A")) {
 686                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS);
 687             } else {
 688                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 689             }
 690         }
 691         executionTaskA = getExecutionTask("A");
 692         assertThat(executionTaskA.getNbRetries()).isEqualTo(2);
 693         SoTaskProcessor.processOrderItem(executionTaskA);
 694         executionTaskA = getExecutionTask("A");
 695         SoTaskProcessor.processOrderItem(executionTaskA);
 696         executionTaskA = getExecutionTask("A");
 697         SoTaskProcessor.processOrderItem(executionTaskA);
 698
 699         serviceOrderChecked = serviceOrderRepository.findOne("test");
 700         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
 701         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 702             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 703
 704         }
 705
 706         assertThat(executionTaskRepository.count()).isEqualTo(0);
 707
 708
 709     }
 710
 711
 712
 713
 714     @Test
 715     public void testExecutionTaskFailedNoSoResponse() throws Exception {
 716
 717         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 718              executionTaskRepository, ActionType.ADD);
 719
 720         removeWireMockMapping("/ecomp/mso/infra/serviceInstances/v6");
 721
 722
 723         SoTaskProcessor.processOrderItem(executionTaskA);
 724         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 725         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
 726         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 727                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 728         }
 729
 730         assertThat(executionTaskRepository.count()).isEqualTo(0);
 731
 732
 733
 734     }
 735
 736     @Test
 737     public void testExecutionTaskFailedNoSoAndStatusResponse() throws Exception {
 738
 739         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 740             executionTaskRepository, ActionType.ADD);
 741
 742         removeWireMockMapping("/ecomp/mso/infra/serviceInstances/v6");
 743         removeWireMockMapping("/ecomp/mso/infra/orchestrationRequests/v6/requestId");
 744
 745
 746         SoTaskProcessor.processOrderItem(executionTaskA);
 747         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 748         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
 749         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 750             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 751         }
 752
 753         assertThat(executionTaskRepository.count()).isEqualTo(0);
 754
 755     }
 756 }