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