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     @Test
 138     @Ignore
 139     public void testServiceResourceGetCatalog() throws Exception {
 140
 141         ResponseEntity<Object> resource =
 142                 serviceSpecificationResource.getServiceSpecification("1e3feeb0-8e36-46c6-862c-236d9c626439", null);
 143         ServiceCatalogAssertions.assertGetServiceCatalog(resource);
 144
 145     }
 146
 147     @Test
 148     public void testServiceCatalogGetResourceWithoutTosca() throws Exception {
 149
 150         ResponseEntity<Object> resource = serviceSpecificationResource
 151                 .getServiceSpecification("1e3feeb0-8e36-46c6-862c-236d9c626439_withoutTosca", null);
 152         ServiceCatalogAssertions.asserGetServiceCatalogWithoutTosca(resource);
 153
 154     }
 155
 156     @Test
 157     public void testServiceCatalogFind() throws Exception {
 158
 159         ResponseEntity<Object> resource = serviceSpecificationResource.findServiceSpecification(null);
 160         ServiceCatalogAssertions.assertFindServiceCatalog(resource);
 161
 162     }
 163
 164
 165     @Test
 166     public void testServiceCatalogFindWithFilter() throws Exception {
 167
 168         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 169         params.add("fields", "name");
 170         ResponseEntity<Object> resource = serviceSpecificationResource.findServiceSpecification(params);
 171         ServiceCatalogAssertions.assertFindServiceCatalogWIthFilter(resource);
 172
 173     }
 174
 175     // serviceInventory
 176
 177     @Test
 178     public void testServiceResourceGetInventory() throws Exception {
 179
 180         String serviceName = "vFW";
 181         String serviceId = "e4688e5f-61a0-4f8b-ae02-a2fbde623bcb";
 182         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 183         params.add("serviceSpecification.name", serviceName);
 184         params.add("relatedParty.id", "6490");
 185         ResponseEntity<Object> resource = serviceInventoryResource.getServiceInventory(serviceId, params);
 186         ServiceInventoryAssertions.assertServiceInventoryGet(resource);
 187
 188     }
 189
 190     @Test
 191     public void testServiceResourceGetInventoryWithoutRelationShipList() throws Exception {
 192
 193         String serviceName = "vFW";
 194         String serviceId = "e4688e5f-61a0-4f8b-ae02-a2fbde623bcbWithoutList";
 195         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 196         params.add("serviceSpecification.name", serviceName);
 197         params.add("relatedParty.id", "6490");
 198         ResponseEntity<Object> resource = serviceInventoryResource.getServiceInventory(serviceId, params);
 199         ServiceInventoryAssertions.assertServiceInventoryGetWithoutList(resource);
 200
 201     }
 202
 203
 204     @Test
 205     public void testServiceResourceGetInventoryWithServiceSpecId() throws Exception {
 206
 207         String serviceId = "e4688e5f-61a0-4f8b-ae02-a2fbde623bcb";
 208         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 209         params.add("serviceSpecification.id", "1e3feeb0-8e36-46c6-862c-236d9c626439");
 210         params.add("relatedParty.id", "6490");
 211         ResponseEntity<Object> resource = serviceInventoryResource.getServiceInventory(serviceId, params);
 212         ServiceInventoryAssertions.assertServiceInventoryGet(resource);
 213
 214     }
 215
 216
 217     @Test
 218     public void testServiceInventoryFind() throws Exception {
 219
 220         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 221         String serviceName = "vFW";
 222         params.add("serviceSpecification.name", serviceName);
 223         params.add("relatedParty.id", "6490");
 224
 225         ResponseEntity<Object> resource = serviceInventoryResource.findServiceInventory(params);
 226         ServiceInventoryAssertions.assertServiceInventoryFind(resource);
 227
 228     }
 229
 230
 231     @Test
 232     public void testServiceInventoryFindWithServiceSpecId() throws Exception {
 233
 234         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 235         params.add("serviceSpecification.id", "1e3feeb0-8e36-46c6-862c-236d9c626439");
 236         params.add("relatedParty.id", "6490");
 237
 238         ResponseEntity<Object> resource = serviceInventoryResource.findServiceInventory(params);
 239         ServiceInventoryAssertions.assertServiceInventoryFind(resource);
 240
 241     }
 242
 243
 244     @Test
 245     public void testServiceInventoryFindWithoutParameter() throws Exception {
 246
 247         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 248         params.add("relatedParty.id", "6490");
 249
 250         ResponseEntity<Object> resource = serviceInventoryResource.findServiceInventory(params);
 251         ServiceInventoryAssertions.assertServiceInventoryFindWithoutParameter(resource);
 252
 253     }
 254
 255     @Test
 256     public void testCreateServiceOrderResource() throws Exception {
 257
 258         ResponseEntity<Object> serviceOrder = serviceOrderResource
 259                 .createServiceOrder(ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD), null, null);
 260         assertThat(serviceOrder.getStatusCodeValue()).isEqualTo(201);
 261         ServiceOrder body = (ServiceOrder) serviceOrder.getBody();
 262         assertThat(body.getId()).isNotNull();
 263         assertThat(body.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 264
 265
 266     }
 267
 268     @Test
 269     public void testCheckServiceOrder() throws Exception {
 270
 271         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 272         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 273         testServiceOrder.setId("test");
 274         serviceOrderRepository.save(testServiceOrder);
 275
 276         serviceOrderResource.scheduleCheckServiceOrders();
 277
 278         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 279         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 280
 281     }
 282
 283     @Test
 284     public void testCheckServiceOrderWithGenericCustomer() throws Exception {
 285
 286         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 287         testServiceOrder.setRelatedParty(new ArrayList<>());
 288         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 289         testServiceOrder.setId("test");
 290         serviceOrderRepository.save(testServiceOrder);
 291
 292         serviceOrderResource.scheduleCheckServiceOrders();
 293
 294         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 295         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 296
 297     }
 298
 299
 300     @Test
 301     public void testCheckServiceOrderWithoutRelatedParty() throws Exception {
 302
 303         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 304         testServiceOrder.setRelatedParty(null);
 305         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 306         testServiceOrder.setId("test");
 307         serviceOrderRepository.save(testServiceOrder);
 308
 309         serviceOrderResource.scheduleCheckServiceOrders();
 310
 311         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 312         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 313
 314
 315     }
 316
 317     @Test
 318     public void testCheckServiceOrderWithUnKnownCustomer() throws Exception {
 319
 320         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 321         List<RelatedParty> customers = new ArrayList<>();
 322         RelatedParty customer = new RelatedParty();
 323         customer.setId("new");
 324         customer.setRole("ONAPcustomer");
 325         customer.setName("romain");
 326         customers.add(customer);
 327         testServiceOrder.setRelatedParty(customers);
 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.ACKNOWLEDGED);
 336
 337     }
 338
 339
 340     @Test
 341     public void testCheckServiceOrderWithCustomerAAINotResponding() throws Exception {
 342
 343         removeWireMockMapping("/aai/v11/business/customers/customer/new");
 344
 345         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 346         List<RelatedParty> customers = new ArrayList<>();
 347         RelatedParty customer = new RelatedParty();
 348         customer.setId("new");
 349         customer.setRole("ONAPcustomer");
 350         customer.setName("romain");
 351         customers.add(customer);
 352         testServiceOrder.setRelatedParty(customers);
 353         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 354         testServiceOrder.setId("test");
 355         serviceOrderRepository.save(testServiceOrder);
 356
 357         serviceOrderResource.scheduleCheckServiceOrders();
 358
 359         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 360         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
 361
 362     }
 363
 364
 365     @Test
 366     public void testCheckServiceOrderWithPutServiceAAINotResponding() throws Exception {
 367
 368         removeWireMockMapping("/aai/v11/business/customers/customer/new/service-subscriptions/service-subscription/vFW");
 369
 370         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 371         List<RelatedParty> customers = new ArrayList<>();
 372         RelatedParty customer = new RelatedParty();
 373         customer.setId("new");
 374         customer.setRole("ONAPcustomer");
 375         customer.setName("romain");
 376         customers.add(customer);
 377         testServiceOrder.setRelatedParty(customers);
 378         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 379         testServiceOrder.setId("test");
 380         serviceOrderRepository.save(testServiceOrder);
 381
 382         serviceOrderResource.scheduleCheckServiceOrders();
 383
 384         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 385         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
 386
 387     }
 388
 389
 390     @Test
 391     public void testCheckServiceOrderDelete() throws Exception {
 392
 393         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 394         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 395         testServiceOrder.setId("test");
 396         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 397             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 398         }
 399         serviceOrderRepository.save(testServiceOrder);
 400
 401         serviceOrderResource.scheduleCheckServiceOrders();
 402
 403         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 404         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 405
 406     }
 407
 408     @Test
 409     public void testCheckServiceOrderDeleteRejected() throws Exception {
 410
 411         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 412         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 413             serviceOrderItem.getService().setId("no_response");
 414
 415         }
 416         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 417         testServiceOrder.setId("test");
 418         serviceOrderRepository.save(testServiceOrder);
 419
 420         serviceOrderResource.scheduleCheckServiceOrders();
 421
 422         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 423         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
 424
 425     }
 426
 427     @Test
 428     public void testCheckServiceOrderNoChange() throws Exception {
 429
 430         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 431         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 432             serviceOrderItem.setAction(ActionType.NOCHANGE);
 433         }
 434
 435         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 436         testServiceOrder.setId("test");
 437         serviceOrderRepository.save(testServiceOrder);
 438
 439         serviceOrderResource.scheduleCheckServiceOrders();
 440
 441         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 442         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 443         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 444             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 445         }
 446
 447     }
 448
 449
 450
 451     @Test
 452     public void testCheckServiceOrderNoChangeAndDelete() throws Exception {
 453
 454         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 455         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 456             if (serviceOrderItem.getId().equals("A")) {
 457                 serviceOrderItem.setAction(ActionType.NOCHANGE);
 458             }
 459             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 460         }
 461
 462         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 463         testServiceOrder.setId("test");
 464         serviceOrderRepository.save(testServiceOrder);
 465
 466         serviceOrderResource.scheduleCheckServiceOrders();
 467
 468         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 469         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 470         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 471             if (serviceOrderItem.getId().equals("A"))
 472                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 473         }
 474     }
 475
 476
 477     @Test
 478     public void testCheckServiceOrderDeleteWithKoServiceSpecId() throws Exception {
 479
 480         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 481         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 482           serviceOrderItem.getService().getServiceSpecification().setId("undefined");
 483         }
 484
 485         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 486         testServiceOrder.setId("test");
 487         serviceOrderRepository.save(testServiceOrder);
 488
 489         serviceOrderResource.scheduleCheckServiceOrders();
 490
 491         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 492         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
 493         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 494             if (serviceOrderItem.getId().equals("A"))
 495                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.REJECTED);
 496         }
 497     }
 498
 499
 500
 501
 502     @Test
 503     public void testCheckServiceOrderRejected() throws Exception {
 504
 505
 506         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrderRejected();
 507         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 508         testServiceOrder.setId("test");
 509         serviceOrderRepository.save(testServiceOrder);
 510
 511         serviceOrderResource.scheduleCheckServiceOrders();
 512
 513         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 514         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
 515
 516     }
 517
 518     @Test
 519     public void validateServiceOrderBeanWithAnnotation() {
 520         ServiceOrder serviceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 521         Set violations = validator.validate(serviceOrder);
 522         assertThat(violations).isEmpty();
 523
 524         ServiceOrderItem item = new ServiceOrderItem();
 525         item.setAction(ActionType.DELETE);
 526         item.setService(new Service());
 527         serviceOrder.addOrderItemItem(item);
 528
 529         violations = validator.validate(serviceOrder);
 530         assertThat(violations).isNotEmpty();
 531     }
 532
 533
 534
 535     @Test
 536     public void testFindAndGetServiceOrder() throws Exception {
 537
 538         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 539         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 540             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 541         }
 542         testServiceOrder.setExternalId("extid1");
 543         testServiceOrder.setOrderDate(new Date());
 544         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 545         testServiceOrder.setDescription("toto");
 546         testServiceOrder.setId("test");
 547         serviceOrderRepository.save(testServiceOrder);
 548
 549
 550         ServiceOrder testServiceOrder2 = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 551         testServiceOrder2.setState(StateType.ACKNOWLEDGED);
 552         testServiceOrder2.setDescription("toto");
 553         testServiceOrder2.setId("test2");
 554         testServiceOrder2.setExternalId("extid2");
 555         testServiceOrder2.setOrderDate(new Date());
 556
 557         serviceOrderRepository.save(testServiceOrder2);
 558
 559
 560         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 561         params.add("fields", "id");
 562
 563         ResponseEntity<Object> serviceOrdersResponse = serviceOrderResource.findServiceOrder(params);
 564         ArrayList serviceOrders = (ArrayList) serviceOrdersResponse.getBody();
 565         assertThat(serviceOrders.size()).isEqualTo(2);
 566
 567         params.add("externalId", "extid1");
 568         params.add("state", "acknowledged");
 569
 570         serviceOrdersResponse = serviceOrderResource.findServiceOrder(params);
 571         serviceOrders = (ArrayList) serviceOrdersResponse.getBody();
 572         assertThat(serviceOrders.size()).isEqualTo(1);
 573
 574         MultiValueMap<String, String> paramsDate = new LinkedMultiValueMap<>();
 575         paramsDate.add("orderDate.gt", "2017-01-01 00:00:00.000");
 576         paramsDate.add("orderDate.lt", "2030-01-01 00:00:00.000");
 577         paramsDate.add("offset", "0");
 578         paramsDate.add("limit", "2");
 579
 580         serviceOrdersResponse = serviceOrderResource.findServiceOrder(paramsDate);
 581         serviceOrders = (ArrayList) serviceOrdersResponse.getBody();
 582         assertThat(serviceOrders.size()).isEqualTo(2);
 583
 584
 585         ResponseEntity<Object> serviceOrderResponse =
 586                 serviceOrderResource.getServiceOrder("test2", new LinkedMultiValueMap<>());
 587         ServiceOrder serviceOrder = (ServiceOrder) serviceOrderResponse.getBody();
 588         assertThat(serviceOrder).isNotNull();
 589     }
 590
 591
 592
 593     @Test
 594     public void testExecutionTaskSuccess() throws Exception {
 595
 596         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 597             executionTaskRepository, ActionType.ADD);
 598         ExecutionTask executionTaskB;
 599
 600
 601         SoTaskProcessor.processOrderItem(executionTaskA);
 602         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 603         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 604         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 605             if (serviceOrderItem.getId().equals("A")) {
 606                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 607             } else {
 608                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 609             }
 610         }
 611
 612         executionTaskB = getExecutionTask("B");
 613         assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 614         executionTaskA = getExecutionTask("A");
 615         assertThat(executionTaskA).isNull();
 616
 617         SoTaskProcessor.processOrderItem(executionTaskB);
 618         serviceOrderChecked = serviceOrderRepository.findOne("test");
 619         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 620         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 621             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 622
 623         }
 624
 625         executionTaskB = getExecutionTask("B");
 626         assertThat(executionTaskB).isNull();
 627
 628
 629     }
 630
 631
 632     @Test
 633     public void testExecutionTaskDeleteSuccess() throws Exception {
 634
 635         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 636             executionTaskRepository, ActionType.DELETE);
 637         ExecutionTask executionTaskB;
 638
 639
 640         SoTaskProcessor.processOrderItem(executionTaskA);
 641         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 642         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 643         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 644             if (serviceOrderItem.getId().equals("A")) {
 645                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 646             } else {
 647                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 648             }
 649         }
 650
 651         executionTaskB = getExecutionTask("B");
 652         assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 653         executionTaskA = getExecutionTask("A");
 654         assertThat(executionTaskA).isNull();
 655
 656         SoTaskProcessor.processOrderItem(executionTaskB);
 657         serviceOrderChecked = serviceOrderRepository.findOne("test");
 658         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 659         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 660             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 661
 662         }
 663
 664         executionTaskB = getExecutionTask("B");
 665         assertThat(executionTaskB).isNull();
 666
 667
 668     }
 669
 670
 671     @Test
 672     public void testExecutionTaskFailed() throws Exception {
 673
 674         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 675             executionTaskRepository, ActionType.ADD);
 676
 677         removeWireMockMapping("/ecomp/mso/infra/orchestrationRequests/v4/requestId");
 678
 679
 680         SoTaskProcessor.processOrderItem(executionTaskA);
 681         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 682         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 683         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 684             if (serviceOrderItem.getId().equals("A")) {
 685                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS);
 686             } else {
 687                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 688             }
 689         }
 690         executionTaskA = getExecutionTask("A");
 691         assertThat(executionTaskA.getNbRetries()).isEqualTo(2);
 692         SoTaskProcessor.processOrderItem(executionTaskA);
 693         executionTaskA = getExecutionTask("A");
 694         SoTaskProcessor.processOrderItem(executionTaskA);
 695         executionTaskA = getExecutionTask("A");
 696         SoTaskProcessor.processOrderItem(executionTaskA);
 697
 698         serviceOrderChecked = serviceOrderRepository.findOne("test");
 699         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
 700         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 701             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 702
 703         }
 704
 705         ExecutionTask executionTaskB = executionTaskRepository.findOne(Long.parseLong("2"));
 706         assertThat(executionTaskB).isNull();
 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/v4");
 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         ExecutionTask executionTaskB = executionTaskRepository.findOne(Long.parseLong("2"));
 731         assertThat(executionTaskB).isNull();
 732
 733
 734     }
 735
 736
 737 }