src/test/java/org/onap/nbi/test/ExecutionTaskTest.java

   1 /**
   2  * Copyright (c) 2018 Orange
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
   5  * in compliance with the License. You may obtain a copy of the License at
   6  *
   7  * http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software distributed under the License
  10  * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
  11  * or implied. See the License for the specific language governing permissions and limitations under
  12  * the License.
  13  */
  14
  15 package org.onap.nbi.test;
  16
  17 import static org.assertj.core.api.Assertions.assertThat;
  18 import java.util.Calendar;
  19 import java.util.Date;
  20 import java.util.List;
  21 import java.util.Optional;
  22 import javax.validation.Validation;
  23 import javax.validation.Validator;
  24 import javax.validation.ValidatorFactory;
  25 import org.junit.After;
  26 import org.junit.AfterClass;
  27 import org.junit.Before;
  28 import org.junit.BeforeClass;
  29 import org.junit.Test;
  30 import org.junit.runner.RunWith;
  31 import org.onap.nbi.apis.assertions.ServiceOrderExecutionTaskAssertions;
  32 import org.onap.nbi.apis.serviceorder.model.ActionType;
  33 import org.onap.nbi.apis.serviceorder.model.ServiceOrder;
  34 import org.onap.nbi.apis.serviceorder.model.ServiceOrderItem;
  35 import org.onap.nbi.apis.serviceorder.model.StateType;
  36 import org.onap.nbi.apis.serviceorder.model.orchestrator.ExecutionTask;
  37 import org.onap.nbi.apis.serviceorder.repositories.ExecutionTaskRepository;
  38 import org.onap.nbi.apis.serviceorder.repositories.ServiceOrderRepository;
  39 import org.onap.nbi.apis.serviceorder.workflow.SOTaskProcessor;
  40 import org.springframework.beans.factory.annotation.Autowired;
  41 import org.springframework.boot.test.context.SpringBootTest;
  42 import org.springframework.mock.web.MockHttpServletRequest;
  43 import org.springframework.test.annotation.DirtiesContext;
  44 import org.springframework.test.annotation.DirtiesContext.ClassMode;
  45 import org.springframework.test.context.ActiveProfiles;
  46 import org.springframework.test.context.junit4.SpringRunner;
  47 import org.springframework.web.context.request.RequestContextHolder;
  48 import org.springframework.web.context.request.ServletRequestAttributes;
  49 import com.github.tomakehurst.wiremock.admin.model.ListStubMappingsResult;
  50 import com.github.tomakehurst.wiremock.http.ResponseDefinition;
  51 import com.github.tomakehurst.wiremock.stubbing.StubMapping;
  52
  53 @RunWith(SpringRunner.class)
  54 @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
  55 @ActiveProfiles("test")
  56 @DirtiesContext(classMode = ClassMode.AFTER_CLASS)
  57 public class ExecutionTaskTest {
  58
  59     @Autowired
  60     ServiceOrderRepository serviceOrderRepository;
  61
  62     @Autowired
  63     ExecutionTaskRepository executionTaskRepository;
  64
  65     @Autowired
  66     SOTaskProcessor SoTaskProcessor;
  67
  68     static Validator validator;
  69
  70     @Before
  71     public void before() {
  72         MockHttpServletRequest request = new MockHttpServletRequest();
  73         RequestContextHolder.setRequestAttributes(new ServletRequestAttributes(request));
  74     }
  75
  76     @BeforeClass
  77     public static void setUp() throws Exception {
  78         ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
  79         validator = factory.getValidator();
  80         Context.startWiremock();
  81     }
  82
  83     @AfterClass
  84     public static void tearsDown() throws Exception {
  85         Context.stopServers();
  86
  87     }
  88
  89     @After
  90     public void tearsDownUpPort() throws Exception {
  91         executionTaskRepository.deleteAll();
  92         serviceOrderRepository.deleteAll();
  93         Context.wireMockServer.resetToDefaultMappings();
  94
  95     }
  96
  97     public ExecutionTask getExecutionTask(String orderItemId) {
  98         for (ExecutionTask executionTask : executionTaskRepository.findAll()) {
  99             if (executionTask.getOrderItemId().equalsIgnoreCase(orderItemId)) {
 100                 return executionTask;
 101             }
 102
 103         }
 104         return null;
 105     }
 106
 107     private void changeWireMockResponse(String s, int statusCode, String bodyContent) {
 108         ListStubMappingsResult listStubMappingsResult = Context.wireMockServer.listAllStubMappings();
 109         ResponseDefinition responseDefinition = new ResponseDefinition(statusCode, bodyContent);
 110         List<StubMapping> mappings = listStubMappingsResult.getMappings();
 111         for (StubMapping mapping : mappings) {
 112             if (mapping.getRequest().getUrl().equals(s)) {
 113                 mapping.setResponse(responseDefinition);
 114             }
 115         }
 116     }
 117
 118     private ServiceOrder getServiceOrder(String serviceOrderId) {
 119         Optional<ServiceOrder> serviceOrderChecked = serviceOrderRepository.findById(serviceOrderId);
 120         return serviceOrderChecked.get();
 121     }
 122
 123     @Test
 124     public void testExecutionTaskSuccess() throws Exception {
 125
 126         ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions
 127                 .setUpBddForExecutionTaskSucess(serviceOrderRepository, executionTaskRepository, ActionType.ADD);
 128         ExecutionTask executionTaskB;
 129
 130         SoTaskProcessor.processOrderItem(executionTaskA);
 131         ServiceOrder serviceOrderChecked = getServiceOrder("test");
 132         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 133         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 134             if (serviceOrderItem.getId().equals("A")) {
 135                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 136             } else {
 137                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 138             }
 139         }
 140
 141         executionTaskB = getExecutionTask("B");
 142         assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 143         executionTaskA = getExecutionTask("A");
 144         assertThat(executionTaskA).isNull();
 145
 146         SoTaskProcessor.processOrderItem(executionTaskB);
 147         serviceOrderChecked = getServiceOrder("test");
 148         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 149         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 150             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 151
 152         }
 153
 154         assertThat(executionTaskRepository.count()).isEqualTo(0);
 155
 156     }
 157
 158     @Test
 159     public void testE2EExecutionTaskSuccess() throws Exception {
 160
 161         ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions
 162                 .setUpBddForE2EExecutionTaskSucess(serviceOrderRepository, executionTaskRepository, ActionType.ADD);
 163         ExecutionTask executionTaskB;
 164
 165         SoTaskProcessor.processOrderItem(executionTaskA);
 166         ServiceOrder serviceOrderChecked = getServiceOrder("test");
 167         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 168         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 169             if (serviceOrderItem.getId().equals("A")) {
 170                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 171             } else {
 172                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 173             }
 174         }
 175
 176         executionTaskB = getExecutionTask("B");
 177         assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 178         executionTaskA = getExecutionTask("A");
 179         assertThat(executionTaskA).isNull();
 180
 181         SoTaskProcessor.processOrderItem(executionTaskB);
 182         serviceOrderChecked = getServiceOrder("test");
 183         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 184         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 185             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 186
 187         }
 188
 189         assertThat(executionTaskRepository.count()).isEqualTo(0);
 190
 191     }
 192
 193     @Test
 194     public void testE2EExecutionTaskSuccessWithObject() throws Exception {
 195
 196         ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions.setUpBddForE2EExecutionTaskSucessWithObject(
 197                 serviceOrderRepository, executionTaskRepository, ActionType.ADD);
 198         ExecutionTask executionTaskB;
 199
 200         SoTaskProcessor.processOrderItem(executionTaskA);
 201         ServiceOrder serviceOrderChecked = getServiceOrder("test");
 202         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 203         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 204             if (serviceOrderItem.getId().equals("A")) {
 205                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 206             } else {
 207                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 208             }
 209         }
 210
 211         executionTaskB = getExecutionTask("B");
 212         assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 213         executionTaskA = getExecutionTask("A");
 214         assertThat(executionTaskA).isNull();
 215
 216         SoTaskProcessor.processOrderItem(executionTaskB);
 217         serviceOrderChecked = getServiceOrder("test");
 218         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 219         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 220             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 221
 222         }
 223
 224         assertThat(executionTaskRepository.count()).isEqualTo(0);
 225
 226     }
 227
 228     @Test
 229     public void testE2EExecutionTaskSuccessWithComplexObject() throws Exception {
 230         // A Service Order with complex object including arrays
 231         ExecutionTask executionTaskA =
 232                 ServiceOrderExecutionTaskAssertions.setUpBddForE2EExecutionTaskSucessWithComplexObject(
 233                         serviceOrderRepository, executionTaskRepository, ActionType.ADD);
 234         ExecutionTask executionTaskB;
 235
 236         SoTaskProcessor.processOrderItem(executionTaskA);
 237         ServiceOrder serviceOrderChecked = getServiceOrder("test");
 238         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 239         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 240             if (serviceOrderItem.getId().equals("A")) {
 241                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 242             } else {
 243                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 244             }
 245         }
 246
 247         executionTaskB = getExecutionTask("B");
 248         assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 249         executionTaskA = getExecutionTask("A");
 250         assertThat(executionTaskA).isNull();
 251
 252         SoTaskProcessor.processOrderItem(executionTaskB);
 253         serviceOrderChecked = getServiceOrder("test");
 254         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 255         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 256             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 257
 258         }
 259
 260         assertThat(executionTaskRepository.count()).isEqualTo(0);
 261
 262     }
 263
 264     @Test
 265     public void testExecutionTaskDeleteSuccess() throws Exception {
 266
 267         ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions
 268                 .setUpBddForExecutionTaskSucess(serviceOrderRepository, executionTaskRepository, ActionType.DELETE);
 269         ExecutionTask executionTaskB;
 270
 271         SoTaskProcessor.processOrderItem(executionTaskA);
 272         ServiceOrder serviceOrderChecked = getServiceOrder("test");
 273         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 274         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 275             if (serviceOrderItem.getId().equals("A")) {
 276                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 277             } else {
 278                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 279             }
 280         }
 281
 282         executionTaskB = getExecutionTask("B");
 283         assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 284         executionTaskA = getExecutionTask("A");
 285         assertThat(executionTaskA).isNull();
 286
 287         SoTaskProcessor.processOrderItem(executionTaskB);
 288         serviceOrderChecked = getServiceOrder("test");
 289         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 290         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 291             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 292
 293         }
 294
 295         assertThat(executionTaskRepository.count()).isEqualTo(0);
 296
 297     }
 298  @Test
 299     public void testE2EExecutionTaskActivationSuccess() throws Exception {
 300
 301         ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions
 302                 .setUpBddForE2EExecutionTaskSucess(serviceOrderRepository, executionTaskRepository, ActionType.MODIFY);
 303         ExecutionTask executionTaskB;
 304
 305         SoTaskProcessor.processOrderItem(executionTaskA);
 306         ServiceOrder serviceOrderChecked = getServiceOrder("test");
 307         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 308         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 309             if (serviceOrderItem.getId().equals("A")) {
 310                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 311             } else {
 312                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 313             }
 314         }
 315
 316         executionTaskB = getExecutionTask("B");
 317         assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 318         executionTaskA = getExecutionTask("A");
 319         assertThat(executionTaskA).isNull();
 320
 321         SoTaskProcessor.processOrderItem(executionTaskB);
 322         serviceOrderChecked = getServiceOrder("test");
 323         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 324         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 325             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 326
 327         }
 328
 329         assertThat(executionTaskRepository.count()).isEqualTo(0);
 330
 331     }
 332
 333
 334     @Test
 335     public void testE2EExecutionTaskDeleteSuccess() throws Exception {
 336
 337         ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions
 338                 .setUpBddForE2EExecutionTaskSucess(serviceOrderRepository, executionTaskRepository, ActionType.DELETE);
 339         ExecutionTask executionTaskB;
 340
 341         SoTaskProcessor.processOrderItem(executionTaskA);
 342         ServiceOrder serviceOrderChecked = getServiceOrder("test");
 343         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 344         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 345             if (serviceOrderItem.getId().equals("A")) {
 346                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 347             } else {
 348                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 349             }
 350         }
 351
 352         executionTaskB = getExecutionTask("B");
 353         assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 354         executionTaskA = getExecutionTask("A");
 355         assertThat(executionTaskA).isNull();
 356
 357         SoTaskProcessor.processOrderItem(executionTaskB);
 358         serviceOrderChecked = getServiceOrder("test");
 359         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 360         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 361             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 362
 363         }
 364
 365         assertThat(executionTaskRepository.count()).isEqualTo(0);
 366
 367     }
 368     //Test Macro Execution Delete
 369       @Test
 370       public void testMacroExecutionTaskDeleteSuccess() throws Exception {
 371
 372         ExecutionTask executionTaskA =ServiceOrderExecutionTaskAssertions.setUpBddForMacroExecutionTaskSucess(
 373                   serviceOrderRepository, executionTaskRepository, ActionType.DELETE);
 374           ExecutionTask executionTaskB;
 375
 376           SoTaskProcessor.processOrderItem(executionTaskA);
 377           ServiceOrder serviceOrderChecked = getServiceOrder("test");
 378           assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 379           for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 380               if (serviceOrderItem.getId().equals("A")) {
 381                   assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 382               } else {
 383                   assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 384               }
 385           }
 386
 387           executionTaskB = getExecutionTask("B");
 388           assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 389           executionTaskA = getExecutionTask("A");
 390           assertThat(executionTaskA).isNull();
 391
 392           SoTaskProcessor.processOrderItem(executionTaskB);
 393           serviceOrderChecked = getServiceOrder("test");
 394           assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 395           for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 396               assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 397
 398           }
 399
 400           assertThat(executionTaskRepository.count()).isEqualTo(0);
 401
 402       }
 403  // Macro Flow Execution Task
 404         @Test
 405         public void testMacroExecutionTaskSuccess() throws Exception {
 406
 407                 ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions
 408                                 .setUpBddForMacroExecutionTaskSucess(serviceOrderRepository, executionTaskRepository, ActionType.ADD);
 409                 ExecutionTask executionTaskB;
 410
 411                 SoTaskProcessor.processOrderItem(executionTaskA);
 412                 ServiceOrder serviceOrderChecked = getServiceOrder("test");
 413                 assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 414                 for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 415                         if (serviceOrderItem.getId().equals("A")) {
 416                                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 417                         } else {
 418                                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 419                         }
 420                 }
 421
 422                 executionTaskB = getExecutionTask("B");
 423                 assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 424                 executionTaskA = getExecutionTask("A");
 425                 assertThat(executionTaskA).isNull();
 426
 427                 SoTaskProcessor.processOrderItem(executionTaskB);
 428                 serviceOrderChecked = getServiceOrder("test");
 429
 430                 assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 431                 for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 432                         assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 433
 434                 }
 435         }
 436
 437         // Macro Flow Execution Task for VNF with Service and VNF level Params
 438          @Test
 439             public void testMacroExecutionTaskSuccessForVNFWithServceAndVnfLevelParams() throws Exception {
 440
 441                 ExecutionTask executionTaskA =
 442                     ServiceOrderExecutionTaskAssertions.setUpBddForMacroExecutionTaskSucessVnf(
 443                         serviceOrderRepository, executionTaskRepository, ActionType.ADD);
 444                 ExecutionTask executionTaskB;
 445
 446                 SoTaskProcessor.processOrderItem(executionTaskA);
 447                 ServiceOrder serviceOrderChecked = getServiceOrder("test");
 448                 assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 449                 for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 450                     if (serviceOrderItem.getId().equals("A")) {
 451                         assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 452                     } else {
 453                         assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 454                     }
 455                 }
 456
 457                 executionTaskB = getExecutionTask("B");
 458                 assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 459                 executionTaskA = getExecutionTask("A");
 460                 assertThat(executionTaskA).isNull();
 461
 462                 SoTaskProcessor.processOrderItem(executionTaskB);
 463                 serviceOrderChecked = getServiceOrder("test");
 464
 465                 assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 466                 for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 467                     assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 468
 469                 }
 470             }
 471
 472         // Macro Flow Execution Task with CNF with InstanceParams
 473                 @Test
 474                 public void testMacroExecutionTaskSuccessforCNFWithServiceAndVNFLevelParams() throws Exception {
 475
 476                         ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions
 477                                         .setUpBddForMacroExecutionTaskSucessForCNF(serviceOrderRepository, executionTaskRepository, ActionType.ADD);
 478                         ExecutionTask executionTaskB;
 479
 480                         SoTaskProcessor.processOrderItem(executionTaskA);
 481                         ServiceOrder serviceOrderChecked = getServiceOrder("test");
 482                         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 483                         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 484                                 if (serviceOrderItem.getId().equals("A")) {
 485                                         assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 486                                 } else {
 487                                         assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 488                                 }
 489                         }
 490
 491                         executionTaskB = getExecutionTask("B");
 492                         assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 493                         executionTaskA = getExecutionTask("A");
 494                         assertThat(executionTaskA).isNull();
 495
 496                         SoTaskProcessor.processOrderItem(executionTaskB);
 497                         serviceOrderChecked = getServiceOrder("test");
 498
 499                         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 500                         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 501                                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 502
 503                         }
 504                 }
 505
 506     @Test
 507     public void testExecutionTaskFailed() throws Exception {
 508
 509         ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions
 510                 .setUpBddForExecutionTaskSucess(serviceOrderRepository, executionTaskRepository, ActionType.ADD);
 511
 512         Context.removeWireMockMapping("/onap/so/infra/orchestrationRequests/v7/requestId");
 513
 514         SoTaskProcessor.processOrderItem(executionTaskA);
 515         ServiceOrder serviceOrderChecked = getServiceOrder("test");
 516         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 517         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 518             if (serviceOrderItem.getId().equals("A")) {
 519                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS);
 520             } else {
 521                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 522             }
 523         }
 524         executionTaskA = getExecutionTask("A");
 525         Date createDate = executionTaskA.getCreateDate();
 526         assertThat(executionTaskA.getLastAttemptDate().getTime() > createDate.getTime()).isTrue();
 527
 528         changeCreationDate(executionTaskA);
 529         SoTaskProcessor.processOrderItem(executionTaskA);
 530
 531         serviceOrderChecked = getServiceOrder("test");
 532         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
 533         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 534             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 535
 536         }
 537
 538         assertThat(executionTaskRepository.count()).isEqualTo(0);
 539
 540     }
 541
 542     private void changeCreationDate(ExecutionTask executionTaskA) {
 543         Calendar cal = Calendar.getInstance();
 544         cal.setTime(executionTaskA.getCreateDate());
 545         cal.add(Calendar.SECOND, -30);
 546         executionTaskA.setCreateDate(cal.getTime());
 547     }
 548
 549     @Test
 550     public void testE2EExecutionTaskFailed() throws Exception {
 551
 552         ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions
 553                 .setUpBddForE2EExecutionTaskSucess(serviceOrderRepository, executionTaskRepository, ActionType.ADD);
 554
 555         Context.removeWireMockMapping("/onap/so/infra/e2eServiceInstances/v3/serviceId/operations/operationId");
 556
 557         SoTaskProcessor.processOrderItem(executionTaskA);
 558         ServiceOrder serviceOrderChecked = getServiceOrder("test");
 559         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 560         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 561             if (serviceOrderItem.getId().equals("A")) {
 562                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS);
 563             } else {
 564                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 565             }
 566         }
 567         executionTaskA = getExecutionTask("A");
 568         assertThat(executionTaskA.getLastAttemptDate().getTime() > executionTaskA.getCreateDate().getTime()).isTrue();
 569         changeCreationDate(executionTaskA);
 570         SoTaskProcessor.processOrderItem(executionTaskA);
 571
 572         serviceOrderChecked = getServiceOrder("test");
 573         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
 574         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 575             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 576
 577         }
 578
 579         assertThat(executionTaskRepository.count()).isEqualTo(0);
 580
 581     }
 582
 583     @Test
 584     public void testExecutionTaskFailedNoSoResponse() throws Exception {
 585
 586         ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions
 587                 .setUpBddForExecutionTaskSucess(serviceOrderRepository, executionTaskRepository, ActionType.ADD);
 588
 589         Context.removeWireMockMapping("/onap/so/infra/serviceInstantiation/v7/serviceInstances");
 590
 591         SoTaskProcessor.processOrderItem(executionTaskA);
 592         ServiceOrder serviceOrderChecked = getServiceOrder("test");
 593         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
 594         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 595             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 596         }
 597
 598         assertThat(executionTaskRepository.count()).isEqualTo(0);
 599
 600     }
 601
 602     @Test
 603     public void testExecutionTaskFailedNoSoAndStatusResponse() throws Exception {
 604
 605         ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions
 606                 .setUpBddForExecutionTaskSucess(serviceOrderRepository, executionTaskRepository, ActionType.ADD);
 607
 608         Context.removeWireMockMapping("/onap/so/infra/serviceInstantiation/v7/serviceInstances");
 609         Context.removeWireMockMapping("/onap/so/infra/orchestrationRequests/v7/requestId");
 610
 611         SoTaskProcessor.processOrderItem(executionTaskA);
 612         ServiceOrder serviceOrderChecked = getServiceOrder("test");
 613         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
 614         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 615             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 616         }
 617
 618         assertThat(executionTaskRepository.count()).isEqualTo(0);
 619
 620     }
 621
 622     @Test
 623     public void testE2EExecutionTaskFailedNoSoAndStatusResponse() throws Exception {
 624
 625         ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions
 626                 .setUpBddForE2EExecutionTaskSucess(serviceOrderRepository, executionTaskRepository, ActionType.ADD);
 627
 628         Context.removeWireMockMapping("/onap/so/infra/e2eServiceInstances/v3");
 629         Context.removeWireMockMapping("/onap/so/infra/e2eServiceInstances/v3/serviceId/operations/operationId");
 630
 631         SoTaskProcessor.processOrderItem(executionTaskA);
 632         ServiceOrder serviceOrderChecked = getServiceOrder("test");
 633         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
 634         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 635             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 636         }
 637
 638         assertThat(executionTaskRepository.count()).isEqualTo(0);
 639
 640     }
 641
 642     @Test
 643     public void testExecutionTaskFailedBadRequestSo() throws Exception {
 644
 645         ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions
 646                 .setUpBddForExecutionTaskSucess(serviceOrderRepository, executionTaskRepository, ActionType.ADD);
 647
 648         changeWireMockResponse("/onap/so/infra/serviceInstantiation/v7/serviceInstances", 400,
 649                 "\"serviceException\": {\n" + "        \"messageId\": \"SVC0002\",\n"
 650                         + "        \"text\": \"Error parsing request.  org.openecomp.mso.apihandler.common.ValidationException: serviceInstance already existsd\"\n"
 651                         + "    }");
 652
 653         SoTaskProcessor.processOrderItem(executionTaskA);
 654         ServiceOrder serviceOrderChecked = getServiceOrder("test");
 655         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
 656         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 657             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 658         }
 659
 660         assertThat(executionTaskRepository.count()).isEqualTo(0);
 661
 662         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 663             if (serviceOrderItem.getId().equals("A")) {
 664                 assertThat(serviceOrderItem.getOrderItemMessage().size()).isEqualTo(1);
 665                 assertThat(serviceOrderItem.getOrderItemMessage().get(0).getCode()).isEqualTo("105");
 666                 assertThat(serviceOrderItem.getOrderItemMessage().get(0).getField()).isEqualTo("service.name");
 667             }
 668         }
 669
 670     }
 671
 672     @Test
 673     public void testExecutionTaskModifySuccess() throws Exception {
 674
 675         ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions
 676                 .setUpBddForExecutionTaskSucess(serviceOrderRepository, executionTaskRepository, ActionType.MODIFY);
 677         ExecutionTask executionTaskB;
 678
 679         SoTaskProcessor.processOrderItem(executionTaskA);
 680         ServiceOrder serviceOrderChecked = getServiceOrder("test");
 681         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 682         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 683             if (serviceOrderItem.getId().equals("A")) {
 684                 // assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS);
 685                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS_MODIFY_ITEM_TO_CREATE);
 686             } else {
 687                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 688             }
 689         }
 690         SoTaskProcessor.processOrderItem(executionTaskA);
 691         serviceOrderChecked = getServiceOrder("test");
 692         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 693         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 694             if (serviceOrderItem.getId().equals("A")) {
 695                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 696             } else {
 697                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 698             }
 699         }
 700
 701         executionTaskB = getExecutionTask("B");
 702         assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 703         executionTaskA = getExecutionTask("A");
 704         assertThat(executionTaskA).isNull();
 705
 706         SoTaskProcessor.processOrderItem(executionTaskB);
 707         SoTaskProcessor.processOrderItem(executionTaskB);
 708
 709         serviceOrderChecked = getServiceOrder("test");
 710         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 711         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 712             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 713
 714         }
 715
 716         assertThat(executionTaskRepository.count()).isEqualTo(0);
 717
 718     }
 719
 720     @Test
 721     public void testExecutionTaskModifyFailed() throws Exception {
 722
 723         ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions
 724                 .setUpBddForExecutionTaskSucess(serviceOrderRepository, executionTaskRepository, ActionType.MODIFY);
 725         ExecutionTask executionTaskB;
 726         Context.removeWireMockMapping("/onap/so/infra/orchestrationRequests/v7/requestId");
 727
 728         SoTaskProcessor.processOrderItem(executionTaskA);
 729         ServiceOrder serviceOrderChecked = getServiceOrder("test");
 730         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 731         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 732             if (serviceOrderItem.getId().equals("A")) {
 733                 // assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS);
 734                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS_MODIFY_REQUEST_DELETE_SEND);
 735             } else {
 736                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 737             }
 738         }
 739         executionTaskA = getExecutionTask("A");
 740         assertThat(executionTaskA.getLastAttemptDate().getTime() > executionTaskA.getCreateDate().getTime()).isTrue();
 741         changeCreationDate(executionTaskA);
 742         SoTaskProcessor.processOrderItem(executionTaskA);
 743
 744         serviceOrderChecked = getServiceOrder("test");
 745         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
 746         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 747             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 748
 749         }
 750
 751         assertThat(executionTaskRepository.count()).isEqualTo(0);
 752
 753     }
 754
 755     @Test
 756     public void testExecutionTaskWithoutOnap() throws Exception {
 757         Context.stopWiremock();
 758         ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions
 759                 .setUpBddForExecutionTaskSucess(serviceOrderRepository, executionTaskRepository, ActionType.ADD);
 760
 761         SoTaskProcessor.processOrderItem(executionTaskA);
 762         ServiceOrder serviceOrderChecked = getServiceOrder("test");
 763         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
 764         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 765             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 766         }
 767         assertThat(serviceOrderChecked.getOrderMessage().size()).isGreaterThan(0);
 768         assertThat(serviceOrderChecked.getOrderMessage().get(0).getCode()).isEqualTo("502");
 769         assertThat(serviceOrderChecked.getOrderMessage().get(0).getMessageInformation())
 770                 .isEqualTo("Problem with SO API");
 771
 772         assertThat(executionTaskRepository.count()).isEqualTo(0);
 773         Context.startWiremock();
 774
 775     }
 776
 777 }