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