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