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
  21 import com.github.tomakehurst.wiremock.WireMockServer;
  22 import com.github.tomakehurst.wiremock.http.ResponseDefinition;
  23 import com.github.tomakehurst.wiremock.stubbing.ListStubMappingsResult;
  24 import com.github.tomakehurst.wiremock.stubbing.StubMapping;
  25 import java.util.ArrayList;
  26 import java.util.Date;
  27 import java.util.List;
  28 import java.util.Set;
  29 import javax.validation.Validation;
  30 import javax.validation.Validator;
  31 import javax.validation.ValidatorFactory;
  32 import org.junit.After;
  33 import org.junit.AfterClass;
  34 import org.junit.BeforeClass;
  35 import org.junit.Ignore;
  36 import org.junit.Test;
  37 import org.junit.runner.RunWith;
  38 import org.onap.nbi.apis.assertions.ServiceCatalogAssertions;
  39 import org.onap.nbi.apis.assertions.ServiceInventoryAssertions;
  40 import org.onap.nbi.apis.assertions.ServiceOrderAssertions;
  41 import org.onap.nbi.apis.servicecatalog.ServiceSpecificationResource;
  42 import org.onap.nbi.apis.serviceinventory.ServiceInventoryResource;
  43 import org.onap.nbi.apis.serviceorder.ServiceOrderResource;
  44 import org.onap.nbi.apis.serviceorder.model.ActionType;
  45 import org.onap.nbi.apis.serviceorder.model.RelatedParty;
  46 import org.onap.nbi.apis.serviceorder.model.Service;
  47 import org.onap.nbi.apis.serviceorder.model.ServiceOrder;
  48 import org.onap.nbi.apis.serviceorder.model.ServiceOrderItem;
  49 import org.onap.nbi.apis.serviceorder.model.StateType;
  50 import org.onap.nbi.apis.serviceorder.model.orchestrator.ExecutionTask;
  51 import org.onap.nbi.apis.serviceorder.repositories.ExecutionTaskRepository;
  52 import org.onap.nbi.apis.serviceorder.repositories.ServiceOrderRepository;
  53 import org.onap.nbi.apis.serviceorder.workflow.SOTaskProcessor;
  54 import org.springframework.beans.factory.annotation.Autowired;
  55 import org.springframework.boot.context.embedded.LocalServerPort;
  56 import org.springframework.boot.test.context.SpringBootTest;
  57 import org.springframework.http.ResponseEntity;
  58 import org.springframework.test.context.junit4.SpringRunner;
  59 import org.springframework.util.LinkedMultiValueMap;
  60 import org.springframework.util.MultiValueMap;
  61
  62 @RunWith(SpringRunner.class)
  63 @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
  64 public class ApiTest {
  65
  66     @LocalServerPort
  67     int randomServerPort;
  68
  69     String realServerPort;
  70
  71     static public WireMockServer wireMockServer = new WireMockServer(8091);
  72
  73     @Autowired
  74     ServiceSpecificationResource serviceSpecificationResource;
  75
  76     @Autowired
  77     ServiceInventoryResource serviceInventoryResource;
  78
  79     @Autowired
  80     ServiceOrderResource serviceOrderResource;
  81
  82     @Autowired
  83     ServiceOrderRepository serviceOrderRepository;
  84
  85     @Autowired
  86     ExecutionTaskRepository executionTaskRepository;
  87
  88     @Autowired
  89     SOTaskProcessor SoTaskProcessor;
  90
  91     static Validator validator;
  92
  93     @BeforeClass
  94     public static void setUp() throws Exception {
  95         wireMockServer.start();
  96         ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
  97         validator = factory.getValidator();
  98     }
  99
 100     @AfterClass
 101     public static void tearsDown() throws Exception {
 102         wireMockServer.stop();
 103
 104     }
 105
 106     @After
 107     public void tearsDownUpPort() throws Exception {
 108         executionTaskRepository.deleteAll();
 109         serviceOrderRepository.deleteAll();
 110         wireMockServer.resetToDefaultMappings();
 111
 112     }
 113
 114
 115     public ExecutionTask getExecutionTask(String orderItemId) {
 116         for (ExecutionTask executionTask : executionTaskRepository.findAll()) {
 117             if (executionTask.getOrderItemId().equalsIgnoreCase(orderItemId)) {
 118                 return executionTask;
 119             }
 120
 121         }
 122         return null;
 123     }
 124
 125     private void removeWireMockMapping(String s) {
 126         ListStubMappingsResult listStubMappingsResult = wireMockServer.listAllStubMappings();
 127         StubMapping mappingToDelete = null;
 128         List<StubMapping> mappings = listStubMappingsResult.getMappings();
 129         for (StubMapping mapping : mappings) {
 130             if (mapping.getRequest().getUrl().equals(s)) {
 131                 mappingToDelete = mapping;
 132             }
 133
 134
 135         }
 136
 137         wireMockServer.removeStubMapping(mappingToDelete);
 138     }
 139
 140     private void changeWireMockResponse(String s,int statusCode, String bodyContent) {
 141         ListStubMappingsResult listStubMappingsResult = wireMockServer.listAllStubMappings();
 142         ResponseDefinition responseDefinition = new ResponseDefinition(statusCode,bodyContent);
 143         List<StubMapping> mappings = listStubMappingsResult.getMappings();
 144         for (StubMapping mapping : mappings) {
 145             if (mapping.getRequest().getUrl().equals(s)) {
 146                 mapping.setResponse(responseDefinition);
 147             }
 148         }
 149     }
 150
 151
 152
 153
 154     // serviceCatalog
 155
 156
 157     @Test
 158     @Ignore
 159     public void testServiceResourceGetCatalog() throws Exception {
 160
 161         ResponseEntity<Object> resource =
 162             serviceSpecificationResource.getServiceSpecification("1e3feeb0-8e36-46c6-862c-236d9c626439", null);
 163         ServiceCatalogAssertions.assertGetServiceCatalog(resource);
 164
 165     }
 166
 167     @Test
 168     public void testServiceCatalogGetResourceWithoutTosca() throws Exception {
 169
 170         ResponseEntity<Object> resource = serviceSpecificationResource
 171             .getServiceSpecification("1e3feeb0-8e36-46c6-862c-236d9c626439_withoutTosca", null);
 172         ServiceCatalogAssertions.assertGetServiceCatalogWithoutTosca(resource);
 173
 174     }
 175
 176     @Test
 177     public void testServiceCatalogFind() throws Exception {
 178
 179         ResponseEntity<Object> resource = serviceSpecificationResource.findServiceSpecification(null);
 180         ServiceCatalogAssertions.assertFindServiceCatalog(resource);
 181
 182     }
 183
 184
 185     @Test
 186     public void testServiceCatalogFindWithFilter() throws Exception {
 187
 188         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 189         params.add("fields", "name");
 190         ResponseEntity<Object> resource = serviceSpecificationResource.findServiceSpecification(params);
 191         ServiceCatalogAssertions.assertFindServiceCatalogWIthFilter(resource);
 192
 193     }
 194
 195     // serviceInventory
 196
 197     @Test
 198     public void testServiceResourceGetInventory() throws Exception {
 199
 200         String serviceName = "vFW";
 201         String serviceId = "e4688e5f-61a0-4f8b-ae02-a2fbde623bcb";
 202         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 203         params.add("serviceSpecification.name", serviceName);
 204         params.add("relatedParty.id", "6490");
 205         ResponseEntity<Object> resource = serviceInventoryResource.getServiceInventory(serviceId, params);
 206         ServiceInventoryAssertions.assertServiceInventoryGet(resource);
 207
 208     }
 209
 210     @Test
 211     public void testServiceResourceGetInventoryWithoutRelationShipList() throws Exception {
 212
 213         String serviceName = "vFW";
 214         String serviceId = "e4688e5f-61a0-4f8b-ae02-a2fbde623bcbWithoutList";
 215         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 216         params.add("serviceSpecification.name", serviceName);
 217         params.add("relatedParty.id", "6490");
 218         ResponseEntity<Object> resource = serviceInventoryResource.getServiceInventory(serviceId, params);
 219         ServiceInventoryAssertions.assertServiceInventoryGetWithoutList(resource);
 220
 221     }
 222
 223
 224     @Test
 225     public void testServiceResourceGetInventoryWithServiceSpecId() throws Exception {
 226
 227         String serviceId = "e4688e5f-61a0-4f8b-ae02-a2fbde623bcb";
 228         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 229         params.add("serviceSpecification.id", "1e3feeb0-8e36-46c6-862c-236d9c626439");
 230         params.add("relatedParty.id", "6490");
 231         ResponseEntity<Object> resource = serviceInventoryResource.getServiceInventory(serviceId, params);
 232         ServiceInventoryAssertions.assertServiceInventoryGet(resource);
 233
 234     }
 235
 236
 237     @Test
 238     public void testServiceInventoryFind() throws Exception {
 239
 240         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 241         String serviceName = "vFW";
 242         params.add("serviceSpecification.name", serviceName);
 243         params.add("relatedParty.id", "6490");
 244
 245         ResponseEntity<Object> resource = serviceInventoryResource.findServiceInventory(params);
 246         ServiceInventoryAssertions.assertServiceInventoryFind(resource);
 247
 248     }
 249
 250
 251     @Test
 252     public void testServiceInventoryFindWithServiceSpecId() throws Exception {
 253
 254         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 255         params.add("serviceSpecification.id", "1e3feeb0-8e36-46c6-862c-236d9c626439");
 256         params.add("relatedParty.id", "6490");
 257
 258         ResponseEntity<Object> resource = serviceInventoryResource.findServiceInventory(params);
 259         ServiceInventoryAssertions.assertServiceInventoryFind(resource);
 260
 261     }
 262
 263
 264     @Test
 265     public void testServiceInventoryFindWithoutParameter() throws Exception {
 266
 267         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 268         params.add("relatedParty.id", "6490");
 269
 270         ResponseEntity<Object> resource = serviceInventoryResource.findServiceInventory(params);
 271         ServiceInventoryAssertions.assertServiceInventoryFindWithoutParameter(resource);
 272
 273     }
 274
 275     @Test
 276     public void testCreateServiceOrderResource() throws Exception {
 277
 278         ResponseEntity<Object> serviceOrder = serviceOrderResource
 279                 .createServiceOrder(ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD), null, null);
 280         assertThat(serviceOrder.getStatusCodeValue()).isEqualTo(201);
 281         ServiceOrder body = (ServiceOrder) serviceOrder.getBody();
 282         assertThat(body.getId()).isNotNull();
 283         assertThat(body.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 284
 285
 286     }
 287
 288     @Test
 289     public void testCheckServiceOrder() throws Exception {
 290
 291         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 292         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 293         testServiceOrder.setId("test");
 294         serviceOrderRepository.save(testServiceOrder);
 295
 296         serviceOrderResource.scheduleCheckServiceOrders();
 297
 298         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 299         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 300
 301     }
 302
 303
 304     @Test
 305     public void testCheckServiceOrderWithUnknownSverviceSpecId() throws Exception {
 306
 307         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 308         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 309         testServiceOrder.setId("test");
 310         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 311             serviceOrderItem.getService().getServiceSpecification().setId("toto");
 312         }
 313
 314         serviceOrderRepository.save(testServiceOrder);
 315
 316         serviceOrderResource.scheduleCheckServiceOrders();
 317
 318         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 319         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
 320         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 321             assertThat(serviceOrderItem.getOrderItemMessage().size()).isEqualTo(1);
 322             assertThat(serviceOrderItem.getOrderItemMessage().get(0).getCode()).isEqualTo("102");
 323             assertThat(serviceOrderItem.getOrderItemMessage().get(0).getField()).isEqualTo("serviceSpecification.id");
 324         }
 325     }
 326
 327     @Test
 328     public void testCheckServiceOrderWithGenericCustomer() throws Exception {
 329
 330         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 331         testServiceOrder.setRelatedParty(new ArrayList<>());
 332         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 333         testServiceOrder.setId("test");
 334         serviceOrderRepository.save(testServiceOrder);
 335
 336         serviceOrderResource.scheduleCheckServiceOrders();
 337
 338         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 339         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 340
 341     }
 342
 343
 344     @Test
 345     public void testCheckServiceOrderWithoutRelatedParty() throws Exception {
 346
 347         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 348         testServiceOrder.setRelatedParty(null);
 349         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 350         testServiceOrder.setId("test");
 351         serviceOrderRepository.save(testServiceOrder);
 352
 353         serviceOrderResource.scheduleCheckServiceOrders();
 354
 355         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 356         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 357
 358
 359     }
 360
 361     @Test
 362     public void testCheckServiceOrderWithUnKnownCustomer() throws Exception {
 363
 364         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 365         List<RelatedParty> customers = new ArrayList<>();
 366         RelatedParty customer = new RelatedParty();
 367         customer.setId("new");
 368         customer.setRole("ONAPcustomer");
 369         customer.setName("romain");
 370         customers.add(customer);
 371         testServiceOrder.setRelatedParty(customers);
 372         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 373         testServiceOrder.setId("test");
 374         serviceOrderRepository.save(testServiceOrder);
 375
 376         serviceOrderResource.scheduleCheckServiceOrders();
 377
 378         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 379         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 380
 381     }
 382
 383     @Test
 384     public void testCheckServiceOrderInDeleteWithNoServiceId() throws Exception {
 385
 386         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 387         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 388             serviceOrderItem.getService().setId(null);
 389         }
 390
 391         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 392         testServiceOrder.setId("test");
 393         serviceOrderRepository.save(testServiceOrder);
 394
 395         serviceOrderResource.scheduleCheckServiceOrders();
 396
 397         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 398         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
 399
 400         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 401             assertThat(serviceOrderItem.getOrderItemMessage().size()).isEqualTo(1);
 402             assertThat(serviceOrderItem.getOrderItemMessage().get(0).getCode()).isEqualTo("101");
 403             assertThat(serviceOrderItem.getOrderItemMessage().get(0).getField()).isEqualTo("service.id");
 404         }
 405     }
 406
 407
 408     @Test
 409     public void testCheckServiceOrderInModifyWithNoServiceId() throws Exception {
 410
 411         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.MODIFY);
 412         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 413             serviceOrderItem.getService().setId(null);
 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         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 426             assertThat(serviceOrderItem.getOrderItemMessage().size()).isEqualTo(1);
 427             assertThat(serviceOrderItem.getOrderItemMessage().get(0).getCode()).isEqualTo("101");
 428             assertThat(serviceOrderItem.getOrderItemMessage().get(0).getField()).isEqualTo("service.id");
 429         }
 430     }
 431
 432     @Test
 433     public void testCheckServiceOrderInAddWithServiceId() throws Exception {
 434
 435         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 436         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 437             serviceOrderItem.getService().setId("toto");
 438         }
 439
 440         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 441         testServiceOrder.setId("test");
 442         serviceOrderRepository.save(testServiceOrder);
 443
 444         serviceOrderResource.scheduleCheckServiceOrders();
 445
 446         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 447         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
 448
 449         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 450             assertThat(serviceOrderItem.getOrderItemMessage().size()).isEqualTo(1);
 451             assertThat(serviceOrderItem.getOrderItemMessage().get(0).getCode()).isEqualTo("103");
 452             assertThat(serviceOrderItem.getOrderItemMessage().get(0).getField()).isEqualTo("service.id");
 453         }
 454     }
 455
 456     @Test
 457     public void testCheckServiceOrderWithUnKnownCustomerInChange() throws Exception {
 458
 459         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 460         List<RelatedParty> customers = new ArrayList<>();
 461         RelatedParty customer = new RelatedParty();
 462         customer.setId("new");
 463         customer.setRole("ONAPcustomer");
 464         customer.setName("romain");
 465         customers.add(customer);
 466         testServiceOrder.setRelatedParty(customers);
 467         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 468         testServiceOrder.setId("test");
 469         serviceOrderRepository.save(testServiceOrder);
 470
 471         serviceOrderResource.scheduleCheckServiceOrders();
 472
 473         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 474         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
 475
 476         assertThat(serviceOrderChecked.getOrderMessage().size()).isGreaterThan(0);
 477         assertThat(serviceOrderChecked.getOrderMessage().get(0).getCode()).isEqualTo("104");
 478         assertThat(serviceOrderChecked.getOrderMessage().get(0).getField()).isEqualTo("relatedParty.id");
 479     }
 480
 481
 482
 483     @Test
 484     public void testCheckServiceOrderWithCustomerAAINotResponding() throws Exception {
 485
 486         removeWireMockMapping("/aai/v11/business/customers/customer/new");
 487
 488         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 489         List<RelatedParty> customers = new ArrayList<>();
 490         RelatedParty customer = new RelatedParty();
 491         customer.setId("new");
 492         customer.setRole("ONAPcustomer");
 493         customer.setName("romain");
 494         customers.add(customer);
 495         testServiceOrder.setRelatedParty(customers);
 496         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 497         testServiceOrder.setId("test");
 498         serviceOrderRepository.save(testServiceOrder);
 499
 500         serviceOrderResource.scheduleCheckServiceOrders();
 501
 502         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 503         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
 504
 505
 506         assertThat(serviceOrderChecked.getOrderMessage().size()).isGreaterThan(0);
 507         assertThat(serviceOrderChecked.getOrderMessage().get(0).getCode()).isEqualTo("501");
 508         assertThat(serviceOrderChecked.getOrderMessage().get(0).getMessageInformation()).isEqualTo("Problem with AAI API");
 509     }
 510
 511
 512     @Test
 513     public void testCheckServiceOrderWithSDCNotResponding() throws Exception {
 514
 515         removeWireMockMapping("/sdc/v1/catalog/services/1e3feeb0-8e36-46c6-862c-236d9c626439/metadata");
 516
 517         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 518         List<RelatedParty> customers = new ArrayList<>();
 519         RelatedParty customer = new RelatedParty();
 520         customer.setId("new");
 521         customer.setRole("ONAPcustomer");
 522         customer.setName("romain");
 523         customers.add(customer);
 524         testServiceOrder.setRelatedParty(customers);
 525         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 526         testServiceOrder.setId("test");
 527         serviceOrderRepository.save(testServiceOrder);
 528
 529         serviceOrderResource.scheduleCheckServiceOrders();
 530
 531         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 532         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
 533
 534
 535         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 536             assertThat(serviceOrderItem.getOrderItemMessage().size()).isEqualTo(1);
 537             assertThat(serviceOrderItem.getOrderItemMessage().get(0).getCode()).isEqualTo("102");
 538             assertThat(serviceOrderItem.getOrderItemMessage().get(0).getField()).isEqualTo("serviceSpecification.id");
 539         }
 540     }
 541
 542
 543
 544
 545     @Test
 546     public void testCheckServiceOrderWithPutServiceAAINotResponding() throws Exception {
 547
 548         removeWireMockMapping("/aai/v11/business/customers/customer/new/service-subscriptions/service-subscription/vFW");
 549
 550         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 551         List<RelatedParty> customers = new ArrayList<>();
 552         RelatedParty customer = new RelatedParty();
 553         customer.setId("new");
 554         customer.setRole("ONAPcustomer");
 555         customer.setName("romain");
 556         customers.add(customer);
 557         testServiceOrder.setRelatedParty(customers);
 558         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 559         testServiceOrder.setId("test");
 560         serviceOrderRepository.save(testServiceOrder);
 561
 562         serviceOrderResource.scheduleCheckServiceOrders();
 563
 564         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 565         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
 566
 567     }
 568
 569
 570     @Test
 571     public void testCheckServiceOrderDelete() throws Exception {
 572
 573         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 574         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 575         testServiceOrder.setId("test");
 576         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 577             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 578         }
 579         serviceOrderRepository.save(testServiceOrder);
 580
 581         serviceOrderResource.scheduleCheckServiceOrders();
 582
 583         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 584         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 585
 586     }
 587
 588     @Test
 589     public void testCheckServiceOrderDeleteRejected() throws Exception {
 590
 591         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 592         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 593             serviceOrderItem.getService().setId("no_response");
 594
 595         }
 596         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 597         testServiceOrder.setId("test");
 598         serviceOrderRepository.save(testServiceOrder);
 599
 600         serviceOrderResource.scheduleCheckServiceOrders();
 601
 602         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 603         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
 604
 605         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 606             assertThat(serviceOrderItem.getOrderItemMessage().size()).isEqualTo(1);
 607             assertThat(serviceOrderItem.getOrderItemMessage().get(0).getCode()).isEqualTo("106");
 608             assertThat(serviceOrderItem.getOrderItemMessage().get(0).getField()).isEqualTo("service.id");
 609         }
 610     }
 611
 612     @Test
 613     public void testCheckServiceOrderNoChange() throws Exception {
 614
 615         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 616         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 617             serviceOrderItem.setAction(ActionType.NOCHANGE);
 618         }
 619
 620         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 621         testServiceOrder.setId("test");
 622         serviceOrderRepository.save(testServiceOrder);
 623
 624         serviceOrderResource.scheduleCheckServiceOrders();
 625
 626         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 627         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 628         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 629             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 630         }
 631
 632     }
 633
 634
 635
 636     @Test
 637     public void testCheckServiceOrderNoChangeAndDelete() throws Exception {
 638
 639         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 640         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 641             if (serviceOrderItem.getId().equals("A")) {
 642                 serviceOrderItem.setAction(ActionType.NOCHANGE);
 643             }
 644             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 645         }
 646
 647         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 648         testServiceOrder.setId("test");
 649         serviceOrderRepository.save(testServiceOrder);
 650
 651         serviceOrderResource.scheduleCheckServiceOrders();
 652
 653         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 654         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 655         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 656             if (serviceOrderItem.getId().equals("A"))
 657                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 658         }
 659     }
 660
 661
 662     @Test
 663     public void testCheckServiceOrderDeleteWithKoServiceSpecId() throws Exception {
 664
 665         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 666         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 667           serviceOrderItem.getService().getServiceSpecification().setId("undefined");
 668         }
 669
 670         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 671         testServiceOrder.setId("test");
 672         serviceOrderRepository.save(testServiceOrder);
 673
 674         serviceOrderResource.scheduleCheckServiceOrders();
 675
 676         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 677         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
 678         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 679             if (serviceOrderItem.getId().equals("A"))
 680                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.REJECTED);
 681         }
 682     }
 683
 684
 685
 686
 687     @Test
 688     public void testCheckServiceOrderRejected() throws Exception {
 689
 690
 691         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrderRejected();
 692         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 693         testServiceOrder.setId("test");
 694         serviceOrderRepository.save(testServiceOrder);
 695
 696         serviceOrderResource.scheduleCheckServiceOrders();
 697
 698         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 699         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
 700
 701         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 702             if(serviceOrderItem.getId().equals("A")) {
 703                 assertThat(serviceOrderItem.getOrderItemMessage().size()).isEqualTo(1);
 704                 assertThat(serviceOrderItem.getOrderItemMessage().get(0).getCode()).isEqualTo("102");
 705                 assertThat(serviceOrderItem.getOrderItemMessage().get(0).getField()).isEqualTo("serviceSpecification.id");
 706             }
 707         }
 708     }
 709
 710     @Test
 711     public void validateServiceOrderBeanWithAnnotation() {
 712         ServiceOrder serviceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 713         Set violations = validator.validate(serviceOrder);
 714         assertThat(violations).isEmpty();
 715
 716         ServiceOrderItem item = new ServiceOrderItem();
 717         item.setAction(ActionType.DELETE);
 718         item.setService(new Service());
 719         serviceOrder.addOrderItemItem(item);
 720
 721         violations = validator.validate(serviceOrder);
 722         assertThat(violations).isNotEmpty();
 723     }
 724
 725
 726
 727     @Test
 728     public void testFindAndGetServiceOrder() throws Exception {
 729
 730         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 731         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 732             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 733         }
 734         testServiceOrder.setExternalId("extid1");
 735         testServiceOrder.setOrderDate(new Date());
 736         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 737         testServiceOrder.setDescription("toto");
 738         testServiceOrder.setId("test");
 739         serviceOrderRepository.save(testServiceOrder);
 740
 741
 742         ServiceOrder testServiceOrder2 = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 743         testServiceOrder2.setState(StateType.ACKNOWLEDGED);
 744         testServiceOrder2.setDescription("toto");
 745         testServiceOrder2.setId("test2");
 746         testServiceOrder2.setExternalId("extid2");
 747         testServiceOrder2.setOrderDate(new Date());
 748
 749         serviceOrderRepository.save(testServiceOrder2);
 750
 751
 752         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 753         params.add("fields", "id");
 754
 755         ResponseEntity<Object> serviceOrdersResponse = serviceOrderResource.findServiceOrder(params);
 756         ArrayList serviceOrders = (ArrayList) serviceOrdersResponse.getBody();
 757         assertThat(serviceOrders.size()).isEqualTo(2);
 758
 759         params.add("externalId", "extid1");
 760         params.add("state", "acknowledged");
 761
 762         serviceOrdersResponse = serviceOrderResource.findServiceOrder(params);
 763         serviceOrders = (ArrayList) serviceOrdersResponse.getBody();
 764         assertThat(serviceOrders.size()).isEqualTo(1);
 765
 766         MultiValueMap<String, String> paramsDate = new LinkedMultiValueMap<>();
 767         paramsDate.add("orderDate.gt", "2017-01-01T00:00:00.000Z");
 768         paramsDate.add("orderDate.lt", "2030-01-01T00:00:00.000Z");
 769         paramsDate.add("offset", "0");
 770         paramsDate.add("limit", "2");
 771
 772         serviceOrdersResponse = serviceOrderResource.findServiceOrder(paramsDate);
 773         serviceOrders = (ArrayList) serviceOrdersResponse.getBody();
 774         assertThat(serviceOrders.size()).isEqualTo(2);
 775
 776
 777         ResponseEntity<Object> serviceOrderResponse =
 778                 serviceOrderResource.getServiceOrder("test2", new LinkedMultiValueMap<>());
 779         ServiceOrder serviceOrder = (ServiceOrder) serviceOrderResponse.getBody();
 780         assertThat(serviceOrder).isNotNull();
 781     }
 782
 783
 784
 785     @Test
 786     public void testExecutionTaskSuccess() throws Exception {
 787
 788         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 789             executionTaskRepository, ActionType.ADD);
 790         ExecutionTask executionTaskB;
 791
 792
 793         SoTaskProcessor.processOrderItem(executionTaskA);
 794         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 795         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 796         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 797             if (serviceOrderItem.getId().equals("A")) {
 798                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 799             } else {
 800                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 801             }
 802         }
 803
 804         executionTaskB = getExecutionTask("B");
 805         assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 806         executionTaskA = getExecutionTask("A");
 807         assertThat(executionTaskA).isNull();
 808
 809         SoTaskProcessor.processOrderItem(executionTaskB);
 810         serviceOrderChecked = serviceOrderRepository.findOne("test");
 811         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 812         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 813             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 814
 815         }
 816
 817         assertThat(executionTaskRepository.count()).isEqualTo(0);
 818
 819
 820
 821     }
 822
 823     @Test
 824     public void testE2EExecutionTaskSuccess() throws Exception {
 825
 826         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForE2EExecutionTaskSucess(serviceOrderRepository,
 827             executionTaskRepository, ActionType.ADD);
 828         ExecutionTask executionTaskB;
 829
 830
 831         SoTaskProcessor.processOrderItem(executionTaskA);
 832         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 833         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 834         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 835             if (serviceOrderItem.getId().equals("A")) {
 836                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 837             } else {
 838                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 839             }
 840         }
 841
 842         executionTaskB = getExecutionTask("B");
 843         assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 844         executionTaskA = getExecutionTask("A");
 845         assertThat(executionTaskA).isNull();
 846
 847         SoTaskProcessor.processOrderItem(executionTaskB);
 848         serviceOrderChecked = serviceOrderRepository.findOne("test");
 849         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 850         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 851             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 852
 853         }
 854
 855         assertThat(executionTaskRepository.count()).isEqualTo(0);
 856
 857
 858
 859     }
 860
 861     @Test
 862     public void testExecutionTaskDeleteSuccess() throws Exception {
 863
 864         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 865             executionTaskRepository, ActionType.DELETE);
 866         ExecutionTask executionTaskB;
 867
 868
 869         SoTaskProcessor.processOrderItem(executionTaskA);
 870         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 871         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 872         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 873             if (serviceOrderItem.getId().equals("A")) {
 874                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 875             } else {
 876                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 877             }
 878         }
 879
 880         executionTaskB = getExecutionTask("B");
 881         assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 882         executionTaskA = getExecutionTask("A");
 883         assertThat(executionTaskA).isNull();
 884
 885         SoTaskProcessor.processOrderItem(executionTaskB);
 886         serviceOrderChecked = serviceOrderRepository.findOne("test");
 887         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 888         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 889             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 890
 891         }
 892
 893         assertThat(executionTaskRepository.count()).isEqualTo(0);
 894
 895
 896
 897     }
 898
 899     @Test
 900     public void testE2EExecutionTaskDeleteSuccess() throws Exception {
 901
 902         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForE2EExecutionTaskSucess(serviceOrderRepository,
 903             executionTaskRepository, ActionType.DELETE);
 904         ExecutionTask executionTaskB;
 905
 906
 907         SoTaskProcessor.processOrderItem(executionTaskA);
 908         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 909         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 910         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 911             if (serviceOrderItem.getId().equals("A")) {
 912                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 913             } else {
 914                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 915             }
 916         }
 917
 918         executionTaskB = getExecutionTask("B");
 919         assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 920         executionTaskA = getExecutionTask("A");
 921         assertThat(executionTaskA).isNull();
 922
 923         SoTaskProcessor.processOrderItem(executionTaskB);
 924         serviceOrderChecked = serviceOrderRepository.findOne("test");
 925         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 926         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 927             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 928
 929         }
 930
 931         assertThat(executionTaskRepository.count()).isEqualTo(0);
 932
 933
 934
 935     }
 936
 937
 938     @Test
 939     public void testExecutionTaskFailed() throws Exception {
 940
 941         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 942             executionTaskRepository, ActionType.ADD);
 943
 944         removeWireMockMapping("/ecomp/mso/infra/orchestrationRequests/v6/requestId");
 945
 946
 947         SoTaskProcessor.processOrderItem(executionTaskA);
 948         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 949         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 950         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 951             if (serviceOrderItem.getId().equals("A")) {
 952                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS);
 953             } else {
 954                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 955             }
 956         }
 957         executionTaskA = getExecutionTask("A");
 958         assertThat(executionTaskA.getNbRetries()).isEqualTo(2);
 959         SoTaskProcessor.processOrderItem(executionTaskA);
 960         executionTaskA = getExecutionTask("A");
 961         SoTaskProcessor.processOrderItem(executionTaskA);
 962         executionTaskA = getExecutionTask("A");
 963         SoTaskProcessor.processOrderItem(executionTaskA);
 964
 965         serviceOrderChecked = serviceOrderRepository.findOne("test");
 966         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
 967         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 968             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 969
 970         }
 971
 972         assertThat(executionTaskRepository.count()).isEqualTo(0);
 973
 974
 975     }
 976
 977
 978     @Test
 979     public void testE2EExecutionTaskFailed() throws Exception {
 980
 981         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForE2EExecutionTaskSucess(serviceOrderRepository,
 982             executionTaskRepository, ActionType.ADD);
 983
 984         removeWireMockMapping("/ecomp/mso/infra/e2eServiceInstances/v3/serviceId/operations/operationId");
 985
 986
 987         SoTaskProcessor.processOrderItem(executionTaskA);
 988         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 989         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 990         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 991             if (serviceOrderItem.getId().equals("A")) {
 992                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS);
 993             } else {
 994                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 995             }
 996         }
 997         executionTaskA = getExecutionTask("A");
 998         assertThat(executionTaskA.getNbRetries()).isEqualTo(2);
 999         SoTaskProcessor.processOrderItem(executionTaskA);
1000         executionTaskA = getExecutionTask("A");
1001         SoTaskProcessor.processOrderItem(executionTaskA);
1002         executionTaskA = getExecutionTask("A");
1003         SoTaskProcessor.processOrderItem(executionTaskA);
1004
1005         serviceOrderChecked = serviceOrderRepository.findOne("test");
1006         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
1007         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
1008             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
1009
1010         }
1011
1012         assertThat(executionTaskRepository.count()).isEqualTo(0);
1013
1014
1015     }
1016
1017     @Test
1018     public void testExecutionTaskFailedNoSoResponse() throws Exception {
1019
1020         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
1021              executionTaskRepository, ActionType.ADD);
1022
1023         removeWireMockMapping("/ecomp/mso/infra/serviceInstances/v6");
1024
1025
1026         SoTaskProcessor.processOrderItem(executionTaskA);
1027         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
1028         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
1029         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
1030                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
1031         }
1032
1033         assertThat(executionTaskRepository.count()).isEqualTo(0);
1034
1035
1036
1037     }
1038
1039     @Test
1040     public void testExecutionTaskFailedNoSoAndStatusResponse() throws Exception {
1041
1042         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
1043             executionTaskRepository, ActionType.ADD);
1044
1045         removeWireMockMapping("/ecomp/mso/infra/serviceInstances/v6");
1046         removeWireMockMapping("/ecomp/mso/infra/orchestrationRequests/v6/requestId");
1047
1048
1049         SoTaskProcessor.processOrderItem(executionTaskA);
1050         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
1051         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
1052         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
1053             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
1054         }
1055
1056         assertThat(executionTaskRepository.count()).isEqualTo(0);
1057
1058     }
1059
1060     @Test
1061     public void testE2EExecutionTaskFailedNoSoAndStatusResponse() throws Exception {
1062
1063         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForE2EExecutionTaskSucess(serviceOrderRepository,
1064             executionTaskRepository, ActionType.ADD);
1065
1066         removeWireMockMapping("/ecomp/mso/infra/e2eServiceInstances/v3");
1067         removeWireMockMapping("/ecomp/mso/infra/e2eServiceInstances/v3/serviceId/operations/operationId");
1068
1069
1070         SoTaskProcessor.processOrderItem(executionTaskA);
1071         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
1072         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
1073         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
1074             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
1075         }
1076
1077         assertThat(executionTaskRepository.count()).isEqualTo(0);
1078
1079     }
1080
1081
1082     @Test
1083     public void testExecutionTaskFailedBadRequestSo() throws Exception {
1084
1085         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
1086             executionTaskRepository, ActionType.ADD);
1087
1088
1089         changeWireMockResponse("/ecomp/mso/infra/serviceInstances/v6",400,"\"serviceException\": {\n"
1090             + "        \"messageId\": \"SVC0002\",\n"
1091             + "        \"text\": \"Error parsing request.  org.openecomp.mso.apihandler.common.ValidationException: serviceInstance already existsd\"\n"
1092             + "    }");
1093
1094
1095         SoTaskProcessor.processOrderItem(executionTaskA);
1096         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
1097         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
1098         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
1099             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
1100         }
1101
1102         assertThat(executionTaskRepository.count()).isEqualTo(0);
1103
1104         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
1105             if(serviceOrderItem.getId().equals("A")) {
1106                 assertThat(serviceOrderItem.getOrderItemMessage().size()).isEqualTo(1);
1107                 assertThat(serviceOrderItem.getOrderItemMessage().get(0).getCode()).isEqualTo("105");
1108                 assertThat(serviceOrderItem.getOrderItemMessage().get(0).getField()).isEqualTo("service.name");
1109             }
1110         }
1111
1112     }
1113
1114
1115     @Test
1116     public void testExecutionTaskModifySuccess() throws Exception {
1117
1118         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
1119             executionTaskRepository, ActionType.MODIFY);
1120         ExecutionTask executionTaskB;
1121
1122
1123         SoTaskProcessor.processOrderItem(executionTaskA);
1124         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
1125         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
1126         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
1127             if (serviceOrderItem.getId().equals("A")) {
1128                 //assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS);
1129                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS_MODIFY_ITEM_TO_CREATE);
1130             } else {
1131                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
1132             }
1133         }
1134         SoTaskProcessor.processOrderItem(executionTaskA);
1135         serviceOrderChecked = serviceOrderRepository.findOne("test");
1136         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
1137         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
1138             if (serviceOrderItem.getId().equals("A")) {
1139                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
1140             } else {
1141                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
1142             }
1143         }
1144
1145         executionTaskB = getExecutionTask("B");
1146         assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
1147         executionTaskA = getExecutionTask("A");
1148         assertThat(executionTaskA).isNull();
1149
1150         SoTaskProcessor.processOrderItem(executionTaskB);
1151         SoTaskProcessor.processOrderItem(executionTaskB);
1152
1153         serviceOrderChecked = serviceOrderRepository.findOne("test");
1154         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
1155         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
1156             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
1157
1158         }
1159
1160         assertThat(executionTaskRepository.count()).isEqualTo(0);
1161
1162     }
1163
1164
1165
1166
1167     @Test
1168     public void testExecutionTaskModifyFailed() throws Exception {
1169
1170         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
1171             executionTaskRepository, ActionType.MODIFY);
1172         ExecutionTask executionTaskB;
1173         removeWireMockMapping("/ecomp/mso/infra/orchestrationRequests/v6/requestId");
1174
1175
1176         SoTaskProcessor.processOrderItem(executionTaskA);
1177         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
1178         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
1179         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
1180             if (serviceOrderItem.getId().equals("A")) {
1181                 //assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS);
1182                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS_MODIFY_REQUEST_DELETE_SEND);
1183             } else {
1184                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
1185             }
1186         }
1187         executionTaskA = getExecutionTask("A");
1188         assertThat(executionTaskA.getNbRetries()).isEqualTo(2);
1189         SoTaskProcessor.processOrderItem(executionTaskA);
1190         executionTaskA = getExecutionTask("A");
1191         SoTaskProcessor.processOrderItem(executionTaskA);
1192         executionTaskA = getExecutionTask("A");
1193         SoTaskProcessor.processOrderItem(executionTaskA);
1194
1195         serviceOrderChecked = serviceOrderRepository.findOne("test");
1196         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
1197         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
1198             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
1199
1200         }
1201
1202         assertThat(executionTaskRepository.count()).isEqualTo(0);
1203
1204     }
1205
1206
1207
1208 }