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.http.ResponseDefinition;
  22 import java.util.ArrayList;
  23 import java.util.Date;
  24 import java.util.List;
  25 import java.util.Set;
  26 import javax.validation.Validation;
  27 import javax.validation.Validator;
  28 import javax.validation.ValidatorFactory;
  29 import org.junit.After;
  30 import org.junit.AfterClass;
  31 import org.junit.BeforeClass;
  32 import org.junit.Ignore;
  33 import org.junit.Test;
  34 import org.junit.runner.RunWith;
  35 import org.onap.nbi.apis.assertions.ServiceCatalogAssertions;
  36 import org.onap.nbi.apis.assertions.ServiceInventoryAssertions;
  37 import org.onap.nbi.apis.assertions.ServiceOrderAssertions;
  38 import org.onap.nbi.apis.servicecatalog.ServiceSpecificationResource;
  39 import org.onap.nbi.apis.serviceinventory.ServiceInventoryResource;
  40 import org.onap.nbi.apis.serviceorder.ServiceOrderResource;
  41 import org.onap.nbi.apis.serviceorder.model.ActionType;
  42 import org.onap.nbi.apis.serviceorder.model.RelatedParty;
  43 import org.onap.nbi.apis.serviceorder.model.Service;
  44 import org.onap.nbi.apis.serviceorder.model.ServiceOrder;
  45 import org.onap.nbi.apis.serviceorder.model.ServiceOrderItem;
  46 import org.onap.nbi.apis.serviceorder.model.StateType;
  47 import org.onap.nbi.apis.serviceorder.model.orchestrator.ExecutionTask;
  48 import org.onap.nbi.apis.serviceorder.repositories.ExecutionTaskRepository;
  49 import org.onap.nbi.apis.serviceorder.repositories.ServiceOrderRepository;
  50 import org.onap.nbi.apis.serviceorder.workflow.SOTaskProcessor;
  51 import org.springframework.beans.factory.annotation.Autowired;
  52 import org.springframework.boot.context.embedded.LocalServerPort;
  53 import org.springframework.boot.test.context.SpringBootTest;
  54 import org.springframework.http.ResponseEntity;
  55 import org.springframework.test.context.junit4.SpringRunner;
  56 import org.springframework.util.LinkedMultiValueMap;
  57 import org.springframework.util.MultiValueMap;
  58 import com.github.tomakehurst.wiremock.WireMockServer;
  59 import com.github.tomakehurst.wiremock.stubbing.ListStubMappingsResult;
  60 import com.github.tomakehurst.wiremock.stubbing.StubMapping;
  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     @Test
 408     public void testCheckServiceOrderInAddWithServiceId() throws Exception {
 409
 410         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 411         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 412             serviceOrderItem.getService().setId("toto");
 413         }
 414
 415         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 416         testServiceOrder.setId("test");
 417         serviceOrderRepository.save(testServiceOrder);
 418
 419         serviceOrderResource.scheduleCheckServiceOrders();
 420
 421         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 422         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
 423
 424         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 425             assertThat(serviceOrderItem.getOrderItemMessage().size()).isEqualTo(1);
 426             assertThat(serviceOrderItem.getOrderItemMessage().get(0).getCode()).isEqualTo("103");
 427             assertThat(serviceOrderItem.getOrderItemMessage().get(0).getField()).isEqualTo("service.id");
 428         }
 429     }
 430
 431     @Test
 432     public void testCheckServiceOrderWithUnKnownCustomerInChange() throws Exception {
 433
 434         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 435         List<RelatedParty> customers = new ArrayList<>();
 436         RelatedParty customer = new RelatedParty();
 437         customer.setId("new");
 438         customer.setRole("ONAPcustomer");
 439         customer.setName("romain");
 440         customers.add(customer);
 441         testServiceOrder.setRelatedParty(customers);
 442         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 443         testServiceOrder.setId("test");
 444         serviceOrderRepository.save(testServiceOrder);
 445
 446         serviceOrderResource.scheduleCheckServiceOrders();
 447
 448         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 449         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
 450
 451         assertThat(serviceOrderChecked.getOrderMessage().size()).isGreaterThan(0);
 452         assertThat(serviceOrderChecked.getOrderMessage().get(0).getCode()).isEqualTo("104");
 453         assertThat(serviceOrderChecked.getOrderMessage().get(0).getField()).isEqualTo("relatedParty.id");
 454     }
 455
 456
 457
 458     @Test
 459     public void testCheckServiceOrderWithCustomerAAINotResponding() throws Exception {
 460
 461         removeWireMockMapping("/aai/v11/business/customers/customer/new");
 462
 463         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 464         List<RelatedParty> customers = new ArrayList<>();
 465         RelatedParty customer = new RelatedParty();
 466         customer.setId("new");
 467         customer.setRole("ONAPcustomer");
 468         customer.setName("romain");
 469         customers.add(customer);
 470         testServiceOrder.setRelatedParty(customers);
 471         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 472         testServiceOrder.setId("test");
 473         serviceOrderRepository.save(testServiceOrder);
 474
 475         serviceOrderResource.scheduleCheckServiceOrders();
 476
 477         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 478         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
 479
 480
 481         assertThat(serviceOrderChecked.getOrderMessage().size()).isGreaterThan(0);
 482         assertThat(serviceOrderChecked.getOrderMessage().get(0).getCode()).isEqualTo("501");
 483         assertThat(serviceOrderChecked.getOrderMessage().get(0).getMessageInformation()).isEqualTo("Problem with AAI API");
 484     }
 485
 486
 487     @Test
 488     public void testCheckServiceOrderWithSDCNotResponding() throws Exception {
 489
 490         removeWireMockMapping("/sdc/v1/catalog/services/1e3feeb0-8e36-46c6-862c-236d9c626439/metadata");
 491
 492         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 493         List<RelatedParty> customers = new ArrayList<>();
 494         RelatedParty customer = new RelatedParty();
 495         customer.setId("new");
 496         customer.setRole("ONAPcustomer");
 497         customer.setName("romain");
 498         customers.add(customer);
 499         testServiceOrder.setRelatedParty(customers);
 500         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 501         testServiceOrder.setId("test");
 502         serviceOrderRepository.save(testServiceOrder);
 503
 504         serviceOrderResource.scheduleCheckServiceOrders();
 505
 506         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 507         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
 508
 509
 510         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 511             assertThat(serviceOrderItem.getOrderItemMessage().size()).isEqualTo(1);
 512             assertThat(serviceOrderItem.getOrderItemMessage().get(0).getCode()).isEqualTo("102");
 513             assertThat(serviceOrderItem.getOrderItemMessage().get(0).getField()).isEqualTo("serviceSpecification.id");
 514         }
 515     }
 516
 517
 518
 519
 520     @Test
 521     public void testCheckServiceOrderWithPutServiceAAINotResponding() throws Exception {
 522
 523         removeWireMockMapping("/aai/v11/business/customers/customer/new/service-subscriptions/service-subscription/vFW");
 524
 525         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 526         List<RelatedParty> customers = new ArrayList<>();
 527         RelatedParty customer = new RelatedParty();
 528         customer.setId("new");
 529         customer.setRole("ONAPcustomer");
 530         customer.setName("romain");
 531         customers.add(customer);
 532         testServiceOrder.setRelatedParty(customers);
 533         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 534         testServiceOrder.setId("test");
 535         serviceOrderRepository.save(testServiceOrder);
 536
 537         serviceOrderResource.scheduleCheckServiceOrders();
 538
 539         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 540         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
 541
 542     }
 543
 544
 545     @Test
 546     public void testCheckServiceOrderDelete() throws Exception {
 547
 548         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 549         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 550         testServiceOrder.setId("test");
 551         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 552             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 553         }
 554         serviceOrderRepository.save(testServiceOrder);
 555
 556         serviceOrderResource.scheduleCheckServiceOrders();
 557
 558         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 559         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 560
 561     }
 562
 563     @Test
 564     public void testCheckServiceOrderDeleteRejected() throws Exception {
 565
 566         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 567         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 568             serviceOrderItem.getService().setId("no_response");
 569
 570         }
 571         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 572         testServiceOrder.setId("test");
 573         serviceOrderRepository.save(testServiceOrder);
 574
 575         serviceOrderResource.scheduleCheckServiceOrders();
 576
 577         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 578         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
 579
 580         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 581             assertThat(serviceOrderItem.getOrderItemMessage().size()).isEqualTo(1);
 582             assertThat(serviceOrderItem.getOrderItemMessage().get(0).getCode()).isEqualTo("106");
 583             assertThat(serviceOrderItem.getOrderItemMessage().get(0).getField()).isEqualTo("service.id");
 584         }
 585     }
 586
 587     @Test
 588     public void testCheckServiceOrderNoChange() throws Exception {
 589
 590         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 591         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 592             serviceOrderItem.setAction(ActionType.NOCHANGE);
 593         }
 594
 595         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 596         testServiceOrder.setId("test");
 597         serviceOrderRepository.save(testServiceOrder);
 598
 599         serviceOrderResource.scheduleCheckServiceOrders();
 600
 601         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 602         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 603         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 604             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 605         }
 606
 607     }
 608
 609
 610
 611     @Test
 612     public void testCheckServiceOrderNoChangeAndDelete() throws Exception {
 613
 614         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 615         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 616             if (serviceOrderItem.getId().equals("A")) {
 617                 serviceOrderItem.setAction(ActionType.NOCHANGE);
 618             }
 619             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 620         }
 621
 622         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 623         testServiceOrder.setId("test");
 624         serviceOrderRepository.save(testServiceOrder);
 625
 626         serviceOrderResource.scheduleCheckServiceOrders();
 627
 628         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 629         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 630         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 631             if (serviceOrderItem.getId().equals("A"))
 632                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 633         }
 634     }
 635
 636
 637     @Test
 638     public void testCheckServiceOrderDeleteWithKoServiceSpecId() throws Exception {
 639
 640         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
 641         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 642           serviceOrderItem.getService().getServiceSpecification().setId("undefined");
 643         }
 644
 645         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 646         testServiceOrder.setId("test");
 647         serviceOrderRepository.save(testServiceOrder);
 648
 649         serviceOrderResource.scheduleCheckServiceOrders();
 650
 651         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 652         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
 653         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 654             if (serviceOrderItem.getId().equals("A"))
 655                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.REJECTED);
 656         }
 657     }
 658
 659
 660
 661
 662     @Test
 663     public void testCheckServiceOrderRejected() throws Exception {
 664
 665
 666         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrderRejected();
 667         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 668         testServiceOrder.setId("test");
 669         serviceOrderRepository.save(testServiceOrder);
 670
 671         serviceOrderResource.scheduleCheckServiceOrders();
 672
 673         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 674         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
 675
 676         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 677             if(serviceOrderItem.getId().equals("A")) {
 678                 assertThat(serviceOrderItem.getOrderItemMessage().size()).isEqualTo(1);
 679                 assertThat(serviceOrderItem.getOrderItemMessage().get(0).getCode()).isEqualTo("102");
 680                 assertThat(serviceOrderItem.getOrderItemMessage().get(0).getField()).isEqualTo("serviceSpecification.id");
 681             }
 682         }
 683     }
 684
 685     @Test
 686     public void validateServiceOrderBeanWithAnnotation() {
 687         ServiceOrder serviceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 688         Set violations = validator.validate(serviceOrder);
 689         assertThat(violations).isEmpty();
 690
 691         ServiceOrderItem item = new ServiceOrderItem();
 692         item.setAction(ActionType.DELETE);
 693         item.setService(new Service());
 694         serviceOrder.addOrderItemItem(item);
 695
 696         violations = validator.validate(serviceOrder);
 697         assertThat(violations).isNotEmpty();
 698     }
 699
 700
 701
 702     @Test
 703     public void testFindAndGetServiceOrder() throws Exception {
 704
 705         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 706         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 707             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 708         }
 709         testServiceOrder.setExternalId("extid1");
 710         testServiceOrder.setOrderDate(new Date());
 711         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 712         testServiceOrder.setDescription("toto");
 713         testServiceOrder.setId("test");
 714         serviceOrderRepository.save(testServiceOrder);
 715
 716
 717         ServiceOrder testServiceOrder2 = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
 718         testServiceOrder2.setState(StateType.ACKNOWLEDGED);
 719         testServiceOrder2.setDescription("toto");
 720         testServiceOrder2.setId("test2");
 721         testServiceOrder2.setExternalId("extid2");
 722         testServiceOrder2.setOrderDate(new Date());
 723
 724         serviceOrderRepository.save(testServiceOrder2);
 725
 726
 727         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 728         params.add("fields", "id");
 729
 730         ResponseEntity<Object> serviceOrdersResponse = serviceOrderResource.findServiceOrder(params);
 731         ArrayList serviceOrders = (ArrayList) serviceOrdersResponse.getBody();
 732         assertThat(serviceOrders.size()).isEqualTo(2);
 733
 734         params.add("externalId", "extid1");
 735         params.add("state", "acknowledged");
 736
 737         serviceOrdersResponse = serviceOrderResource.findServiceOrder(params);
 738         serviceOrders = (ArrayList) serviceOrdersResponse.getBody();
 739         assertThat(serviceOrders.size()).isEqualTo(1);
 740
 741         MultiValueMap<String, String> paramsDate = new LinkedMultiValueMap<>();
 742         paramsDate.add("orderDate.gt", "2017-01-01T00:00:00.000Z");
 743         paramsDate.add("orderDate.lt", "2030-01-01T00:00:00.000Z");
 744         paramsDate.add("offset", "0");
 745         paramsDate.add("limit", "2");
 746
 747         serviceOrdersResponse = serviceOrderResource.findServiceOrder(paramsDate);
 748         serviceOrders = (ArrayList) serviceOrdersResponse.getBody();
 749         assertThat(serviceOrders.size()).isEqualTo(2);
 750
 751
 752         ResponseEntity<Object> serviceOrderResponse =
 753                 serviceOrderResource.getServiceOrder("test2", new LinkedMultiValueMap<>());
 754         ServiceOrder serviceOrder = (ServiceOrder) serviceOrderResponse.getBody();
 755         assertThat(serviceOrder).isNotNull();
 756     }
 757
 758
 759
 760     @Test
 761     public void testExecutionTaskSuccess() throws Exception {
 762
 763         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 764             executionTaskRepository, ActionType.ADD);
 765         ExecutionTask executionTaskB;
 766
 767
 768         SoTaskProcessor.processOrderItem(executionTaskA);
 769         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 770         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 771         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 772             if (serviceOrderItem.getId().equals("A")) {
 773                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 774             } else {
 775                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 776             }
 777         }
 778
 779         executionTaskB = getExecutionTask("B");
 780         assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 781         executionTaskA = getExecutionTask("A");
 782         assertThat(executionTaskA).isNull();
 783
 784         SoTaskProcessor.processOrderItem(executionTaskB);
 785         serviceOrderChecked = serviceOrderRepository.findOne("test");
 786         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 787         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 788             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 789
 790         }
 791
 792         assertThat(executionTaskRepository.count()).isEqualTo(0);
 793
 794
 795
 796     }
 797
 798     @Test
 799     public void testE2EExecutionTaskSuccess() throws Exception {
 800
 801         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForE2EExecutionTaskSucess(serviceOrderRepository,
 802             executionTaskRepository, ActionType.ADD);
 803         ExecutionTask executionTaskB;
 804
 805
 806         SoTaskProcessor.processOrderItem(executionTaskA);
 807         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 808         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 809         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 810             if (serviceOrderItem.getId().equals("A")) {
 811                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 812             } else {
 813                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 814             }
 815         }
 816
 817         executionTaskB = getExecutionTask("B");
 818         assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 819         executionTaskA = getExecutionTask("A");
 820         assertThat(executionTaskA).isNull();
 821
 822         SoTaskProcessor.processOrderItem(executionTaskB);
 823         serviceOrderChecked = serviceOrderRepository.findOne("test");
 824         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 825         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 826             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 827
 828         }
 829
 830         assertThat(executionTaskRepository.count()).isEqualTo(0);
 831
 832
 833
 834     }
 835
 836     @Test
 837     public void testExecutionTaskDeleteSuccess() throws Exception {
 838
 839         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 840             executionTaskRepository, ActionType.DELETE);
 841         ExecutionTask executionTaskB;
 842
 843
 844         SoTaskProcessor.processOrderItem(executionTaskA);
 845         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 846         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 847         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 848             if (serviceOrderItem.getId().equals("A")) {
 849                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 850             } else {
 851                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 852             }
 853         }
 854
 855         executionTaskB = getExecutionTask("B");
 856         assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 857         executionTaskA = getExecutionTask("A");
 858         assertThat(executionTaskA).isNull();
 859
 860         SoTaskProcessor.processOrderItem(executionTaskB);
 861         serviceOrderChecked = serviceOrderRepository.findOne("test");
 862         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 863         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 864             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 865
 866         }
 867
 868         assertThat(executionTaskRepository.count()).isEqualTo(0);
 869
 870
 871
 872     }
 873
 874     @Test
 875     public void testE2EExecutionTaskDeleteSuccess() throws Exception {
 876
 877         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForE2EExecutionTaskSucess(serviceOrderRepository,
 878             executionTaskRepository, ActionType.DELETE);
 879         ExecutionTask executionTaskB;
 880
 881
 882         SoTaskProcessor.processOrderItem(executionTaskA);
 883         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 884         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 885         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 886             if (serviceOrderItem.getId().equals("A")) {
 887                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 888             } else {
 889                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 890             }
 891         }
 892
 893         executionTaskB = getExecutionTask("B");
 894         assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 895         executionTaskA = getExecutionTask("A");
 896         assertThat(executionTaskA).isNull();
 897
 898         SoTaskProcessor.processOrderItem(executionTaskB);
 899         serviceOrderChecked = serviceOrderRepository.findOne("test");
 900         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 901         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 902             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 903
 904         }
 905
 906         assertThat(executionTaskRepository.count()).isEqualTo(0);
 907
 908
 909
 910     }
 911
 912
 913     @Test
 914     public void testExecutionTaskFailed() throws Exception {
 915
 916         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 917             executionTaskRepository, ActionType.ADD);
 918
 919         removeWireMockMapping("/ecomp/mso/infra/orchestrationRequests/v6/requestId");
 920
 921
 922         SoTaskProcessor.processOrderItem(executionTaskA);
 923         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 924         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 925         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 926             if (serviceOrderItem.getId().equals("A")) {
 927                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS);
 928             } else {
 929                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 930             }
 931         }
 932         executionTaskA = getExecutionTask("A");
 933         assertThat(executionTaskA.getNbRetries()).isEqualTo(2);
 934         SoTaskProcessor.processOrderItem(executionTaskA);
 935         executionTaskA = getExecutionTask("A");
 936         SoTaskProcessor.processOrderItem(executionTaskA);
 937         executionTaskA = getExecutionTask("A");
 938         SoTaskProcessor.processOrderItem(executionTaskA);
 939
 940         serviceOrderChecked = serviceOrderRepository.findOne("test");
 941         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
 942         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 943             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 944
 945         }
 946
 947         assertThat(executionTaskRepository.count()).isEqualTo(0);
 948
 949
 950     }
 951
 952
 953     @Test
 954     public void testE2EExecutionTaskFailed() throws Exception {
 955
 956         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForE2EExecutionTaskSucess(serviceOrderRepository,
 957             executionTaskRepository, ActionType.ADD);
 958
 959         removeWireMockMapping("/ecomp/mso/infra/e2eServiceInstances/v3/serviceId/operations/operationId");
 960
 961
 962         SoTaskProcessor.processOrderItem(executionTaskA);
 963         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
 964         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 965         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 966             if (serviceOrderItem.getId().equals("A")) {
 967                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS);
 968             } else {
 969                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 970             }
 971         }
 972         executionTaskA = getExecutionTask("A");
 973         assertThat(executionTaskA.getNbRetries()).isEqualTo(2);
 974         SoTaskProcessor.processOrderItem(executionTaskA);
 975         executionTaskA = getExecutionTask("A");
 976         SoTaskProcessor.processOrderItem(executionTaskA);
 977         executionTaskA = getExecutionTask("A");
 978         SoTaskProcessor.processOrderItem(executionTaskA);
 979
 980         serviceOrderChecked = serviceOrderRepository.findOne("test");
 981         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
 982         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 983             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 984
 985         }
 986
 987         assertThat(executionTaskRepository.count()).isEqualTo(0);
 988
 989
 990     }
 991
 992     @Test
 993     public void testExecutionTaskFailedNoSoResponse() throws Exception {
 994
 995         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 996              executionTaskRepository, ActionType.ADD);
 997
 998         removeWireMockMapping("/ecomp/mso/infra/serviceInstances/v6");
 999
1000
1001         SoTaskProcessor.processOrderItem(executionTaskA);
1002         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
1003         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
1004         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
1005                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
1006         }
1007
1008         assertThat(executionTaskRepository.count()).isEqualTo(0);
1009
1010
1011
1012     }
1013
1014     @Test
1015     public void testExecutionTaskFailedNoSoAndStatusResponse() throws Exception {
1016
1017         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
1018             executionTaskRepository, ActionType.ADD);
1019
1020         removeWireMockMapping("/ecomp/mso/infra/serviceInstances/v6");
1021         removeWireMockMapping("/ecomp/mso/infra/orchestrationRequests/v6/requestId");
1022
1023
1024         SoTaskProcessor.processOrderItem(executionTaskA);
1025         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
1026         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
1027         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
1028             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
1029         }
1030
1031         assertThat(executionTaskRepository.count()).isEqualTo(0);
1032
1033     }
1034
1035     @Test
1036     public void testE2EExecutionTaskFailedNoSoAndStatusResponse() throws Exception {
1037
1038         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForE2EExecutionTaskSucess(serviceOrderRepository,
1039             executionTaskRepository, ActionType.ADD);
1040
1041         removeWireMockMapping("/ecomp/mso/infra/e2eServiceInstances/v3");
1042         removeWireMockMapping("/ecomp/mso/infra/e2eServiceInstances/v3/serviceId/operations/operationId");
1043
1044
1045         SoTaskProcessor.processOrderItem(executionTaskA);
1046         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
1047         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
1048         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
1049             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
1050         }
1051
1052         assertThat(executionTaskRepository.count()).isEqualTo(0);
1053
1054     }
1055
1056
1057     @Test
1058     public void testExecutionTaskFailedBadRequestSo() throws Exception {
1059
1060         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
1061             executionTaskRepository, ActionType.ADD);
1062
1063
1064         changeWireMockResponse("/ecomp/mso/infra/serviceInstances/v6",400,"\"serviceException\": {\n"
1065             + "        \"messageId\": \"SVC0002\",\n"
1066             + "        \"text\": \"Error parsing request.  org.openecomp.mso.apihandler.common.ValidationException: serviceInstance already existsd\"\n"
1067             + "    }");
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         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
1080             if(serviceOrderItem.getId().equals("A")) {
1081                 assertThat(serviceOrderItem.getOrderItemMessage().size()).isEqualTo(1);
1082                 assertThat(serviceOrderItem.getOrderItemMessage().get(0).getCode()).isEqualTo("105");
1083                 assertThat(serviceOrderItem.getOrderItemMessage().get(0).getField()).isEqualTo("service.name");
1084             }
1085         }
1086
1087     }
1088
1089
1090 }