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 package org.onap.nbi.test;
  15
  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
  69   static Validator validator;
  70
  71   @Before
  72   public void before() {
  73     MockHttpServletRequest request = new MockHttpServletRequest();
  74     RequestContextHolder.setRequestAttributes(new ServletRequestAttributes(request));
  75   }
  76
  77   @BeforeClass
  78   public static void setUp() throws Exception {
  79     ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
  80     validator = factory.getValidator();
  81     Context.startWiremock();
  82   }
  83
  84   @AfterClass
  85   public static void tearsDown() throws Exception {
  86     Context.stopServers();
  87
  88   }
  89
  90   @After
  91   public void tearsDownUpPort() throws Exception {
  92     executionTaskRepository.deleteAll();
  93     serviceOrderRepository.deleteAll();
  94     Context.wireMockServer.resetToDefaultMappings();
  95
  96   }
  97
  98
  99   public ExecutionTask getExecutionTask(String orderItemId) {
 100     for (ExecutionTask executionTask : executionTaskRepository.findAll()) {
 101       if (executionTask.getOrderItemId().equalsIgnoreCase(orderItemId)) {
 102         return executionTask;
 103       }
 104
 105     }
 106     return null;
 107   }
 108
 109   private void changeWireMockResponse(String s, int statusCode, String bodyContent) {
 110     ListStubMappingsResult listStubMappingsResult = Context.wireMockServer.listAllStubMappings();
 111     ResponseDefinition responseDefinition = new ResponseDefinition(statusCode, bodyContent);
 112     List<StubMapping> mappings = listStubMappingsResult.getMappings();
 113     for (StubMapping mapping : mappings) {
 114       if (mapping.getRequest().getUrl().equals(s)) {
 115         mapping.setResponse(responseDefinition);
 116       }
 117     }
 118   }
 119
 120
 121   private ServiceOrder getServiceOrder(String serviceOrderId) {
 122     Optional<ServiceOrder> serviceOrderChecked = serviceOrderRepository.findById(serviceOrderId);
 123     return serviceOrderChecked.get();
 124   }
 125
 126
 127
 128   @Test
 129   public void testExecutionTaskSuccess() throws Exception {
 130
 131     ExecutionTask executionTaskA =
 132         ServiceOrderExecutionTaskAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 133             executionTaskRepository, ActionType.ADD);
 134     ExecutionTask executionTaskB;
 135
 136
 137     SoTaskProcessor.processOrderItem(executionTaskA);
 138     ServiceOrder serviceOrderChecked = getServiceOrder("test");
 139     assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 140     for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 141       if (serviceOrderItem.getId().equals("A")) {
 142         assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 143       } else {
 144         assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 145       }
 146     }
 147
 148     executionTaskB = getExecutionTask("B");
 149     assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 150     executionTaskA = getExecutionTask("A");
 151     assertThat(executionTaskA).isNull();
 152
 153     SoTaskProcessor.processOrderItem(executionTaskB);
 154     serviceOrderChecked = getServiceOrder("test");
 155     assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 156     for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 157       assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 158
 159     }
 160
 161     assertThat(executionTaskRepository.count()).isEqualTo(0);
 162
 163
 164
 165   }
 166
 167   @Test
 168   public void testE2EExecutionTaskSuccess() throws Exception {
 169
 170     ExecutionTask executionTaskA =
 171         ServiceOrderExecutionTaskAssertions.setUpBddForE2EExecutionTaskSucess(
 172             serviceOrderRepository, executionTaskRepository, ActionType.ADD);
 173     ExecutionTask executionTaskB;
 174
 175
 176     SoTaskProcessor.processOrderItem(executionTaskA);
 177     ServiceOrder serviceOrderChecked = getServiceOrder("test");
 178     assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 179     for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 180       if (serviceOrderItem.getId().equals("A")) {
 181         assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 182       } else {
 183         assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 184       }
 185     }
 186
 187     executionTaskB = getExecutionTask("B");
 188     assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 189     executionTaskA = getExecutionTask("A");
 190     assertThat(executionTaskA).isNull();
 191
 192     SoTaskProcessor.processOrderItem(executionTaskB);
 193     serviceOrderChecked = getServiceOrder("test");
 194     assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 195     for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 196       assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 197
 198     }
 199
 200     assertThat(executionTaskRepository.count()).isEqualTo(0);
 201
 202
 203
 204   }
 205
 206   @Test
 207   public void testE2EExecutionTaskSuccessWithObject() throws Exception {
 208
 209     ExecutionTask executionTaskA =
 210         ServiceOrderExecutionTaskAssertions.setUpBddForE2EExecutionTaskSucessWithObject(
 211             serviceOrderRepository, executionTaskRepository, ActionType.ADD);
 212     ExecutionTask executionTaskB;
 213
 214
 215     SoTaskProcessor.processOrderItem(executionTaskA);
 216     ServiceOrder serviceOrderChecked = getServiceOrder("test");
 217     assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 218     for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 219       if (serviceOrderItem.getId().equals("A")) {
 220         assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 221       } else {
 222         assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 223       }
 224     }
 225
 226     executionTaskB = getExecutionTask("B");
 227     assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 228     executionTaskA = getExecutionTask("A");
 229     assertThat(executionTaskA).isNull();
 230
 231     SoTaskProcessor.processOrderItem(executionTaskB);
 232     serviceOrderChecked = getServiceOrder("test");
 233     assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 234     for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 235       assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 236
 237     }
 238
 239     assertThat(executionTaskRepository.count()).isEqualTo(0);
 240
 241
 242
 243   }
 244
 245   @Test
 246   public void testE2EExecutionTaskSuccessWithComplexObject() throws Exception {
 247     // A Service Order with complex object including arrays
 248     ExecutionTask executionTaskA =
 249         ServiceOrderExecutionTaskAssertions.setUpBddForE2EExecutionTaskSucessWithComplexObject(
 250             serviceOrderRepository, executionTaskRepository, ActionType.ADD);
 251     ExecutionTask executionTaskB;
 252
 253
 254     SoTaskProcessor.processOrderItem(executionTaskA);
 255     ServiceOrder serviceOrderChecked = getServiceOrder("test");
 256     assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 257     for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 258       if (serviceOrderItem.getId().equals("A")) {
 259         assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 260       } else {
 261         assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 262       }
 263     }
 264
 265     executionTaskB = getExecutionTask("B");
 266     assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 267     executionTaskA = getExecutionTask("A");
 268     assertThat(executionTaskA).isNull();
 269
 270     SoTaskProcessor.processOrderItem(executionTaskB);
 271     serviceOrderChecked = getServiceOrder("test");
 272     assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 273     for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 274       assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 275
 276     }
 277
 278     assertThat(executionTaskRepository.count()).isEqualTo(0);
 279
 280
 281
 282   }
 283
 284   @Test
 285   public void testExecutionTaskDeleteSuccess() throws Exception {
 286
 287     ExecutionTask executionTaskA =
 288         ServiceOrderExecutionTaskAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 289             executionTaskRepository, ActionType.DELETE);
 290     ExecutionTask executionTaskB;
 291
 292
 293     SoTaskProcessor.processOrderItem(executionTaskA);
 294     ServiceOrder serviceOrderChecked = getServiceOrder("test");
 295     assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 296     for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 297       if (serviceOrderItem.getId().equals("A")) {
 298         assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 299       } else {
 300         assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 301       }
 302     }
 303
 304     executionTaskB = getExecutionTask("B");
 305     assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 306     executionTaskA = getExecutionTask("A");
 307     assertThat(executionTaskA).isNull();
 308
 309     SoTaskProcessor.processOrderItem(executionTaskB);
 310     serviceOrderChecked = getServiceOrder("test");
 311     assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 312     for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 313       assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 314
 315     }
 316
 317     assertThat(executionTaskRepository.count()).isEqualTo(0);
 318
 319
 320
 321   }
 322
 323   @Test
 324   public void testE2EExecutionTaskDeleteSuccess() throws Exception {
 325
 326     ExecutionTask executionTaskA =
 327         ServiceOrderExecutionTaskAssertions.setUpBddForE2EExecutionTaskSucess(
 328             serviceOrderRepository, executionTaskRepository, ActionType.DELETE);
 329     ExecutionTask executionTaskB;
 330
 331
 332     SoTaskProcessor.processOrderItem(executionTaskA);
 333     ServiceOrder serviceOrderChecked = getServiceOrder("test");
 334     assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 335     for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 336       if (serviceOrderItem.getId().equals("A")) {
 337         assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 338       } else {
 339         assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 340       }
 341     }
 342
 343     executionTaskB = getExecutionTask("B");
 344     assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 345     executionTaskA = getExecutionTask("A");
 346     assertThat(executionTaskA).isNull();
 347
 348     SoTaskProcessor.processOrderItem(executionTaskB);
 349     serviceOrderChecked = getServiceOrder("test");
 350     assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 351     for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 352       assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 353
 354     }
 355
 356     assertThat(executionTaskRepository.count()).isEqualTo(0);
 357
 358
 359
 360   }
 361
 362
 363   @Test
 364   public void testExecutionTaskFailed() throws Exception {
 365
 366     ExecutionTask executionTaskA =
 367         ServiceOrderExecutionTaskAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 368             executionTaskRepository, ActionType.ADD);
 369
 370     Context.removeWireMockMapping("/onap/so/infra/orchestrationRequests/v7/requestId");
 371
 372
 373     SoTaskProcessor.processOrderItem(executionTaskA);
 374     ServiceOrder serviceOrderChecked = getServiceOrder("test");
 375     assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 376     for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 377       if (serviceOrderItem.getId().equals("A")) {
 378         assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS);
 379       } else {
 380         assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 381       }
 382     }
 383     executionTaskA = getExecutionTask("A");
 384     Date createDate = executionTaskA.getCreateDate();
 385     assertThat(executionTaskA.getLastAttemptDate().getTime() > createDate.getTime()).isTrue();
 386
 387     changeCreationDate(executionTaskA);
 388     SoTaskProcessor.processOrderItem(executionTaskA);
 389
 390     serviceOrderChecked = getServiceOrder("test");
 391     assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
 392     for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 393       assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 394
 395     }
 396
 397     assertThat(executionTaskRepository.count()).isEqualTo(0);
 398
 399
 400   }
 401
 402   private void changeCreationDate(ExecutionTask executionTaskA) {
 403     Calendar cal = Calendar.getInstance();
 404     cal.setTime(executionTaskA.getCreateDate());
 405     cal.add(Calendar.SECOND, -30);
 406     executionTaskA.setCreateDate(cal.getTime());
 407   }
 408
 409
 410   @Test
 411   public void testE2EExecutionTaskFailed() throws Exception {
 412
 413     ExecutionTask executionTaskA =
 414         ServiceOrderExecutionTaskAssertions.setUpBddForE2EExecutionTaskSucess(
 415             serviceOrderRepository, executionTaskRepository, ActionType.ADD);
 416
 417     Context.removeWireMockMapping(
 418         "/onap/so/infra/e2eServiceInstances/v3/serviceId/operations/operationId");
 419
 420
 421     SoTaskProcessor.processOrderItem(executionTaskA);
 422     ServiceOrder serviceOrderChecked = getServiceOrder("test");
 423     assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 424     for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 425       if (serviceOrderItem.getId().equals("A")) {
 426         assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS);
 427       } else {
 428         assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 429       }
 430     }
 431     executionTaskA = getExecutionTask("A");
 432     assertThat(
 433         executionTaskA.getLastAttemptDate().getTime() > executionTaskA.getCreateDate().getTime())
 434             .isTrue();
 435     changeCreationDate(executionTaskA);
 436     SoTaskProcessor.processOrderItem(executionTaskA);
 437
 438     serviceOrderChecked = getServiceOrder("test");
 439     assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
 440     for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 441       assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 442
 443     }
 444
 445     assertThat(executionTaskRepository.count()).isEqualTo(0);
 446
 447
 448   }
 449
 450   @Test
 451   public void testExecutionTaskFailedNoSoResponse() throws Exception {
 452
 453     ExecutionTask executionTaskA =
 454         ServiceOrderExecutionTaskAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 455             executionTaskRepository, ActionType.ADD);
 456
 457     Context.removeWireMockMapping("/onap/so/infra/serviceInstantiation/v7/serviceInstances/");
 458
 459
 460     SoTaskProcessor.processOrderItem(executionTaskA);
 461     ServiceOrder serviceOrderChecked = getServiceOrder("test");
 462     assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
 463     for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 464       assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 465     }
 466
 467     assertThat(executionTaskRepository.count()).isEqualTo(0);
 468
 469
 470
 471   }
 472
 473   @Test
 474   public void testExecutionTaskFailedNoSoAndStatusResponse() throws Exception {
 475
 476     ExecutionTask executionTaskA =
 477         ServiceOrderExecutionTaskAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 478             executionTaskRepository, ActionType.ADD);
 479
 480     Context.removeWireMockMapping("/onap/so/infra/serviceInstantiation/v7/serviceInstances/");
 481     Context.removeWireMockMapping("/onap/so/infra/orchestrationRequests/v7/requestId");
 482
 483
 484     SoTaskProcessor.processOrderItem(executionTaskA);
 485     ServiceOrder serviceOrderChecked = getServiceOrder("test");
 486     assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
 487     for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 488       assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 489     }
 490
 491     assertThat(executionTaskRepository.count()).isEqualTo(0);
 492
 493   }
 494
 495   @Test
 496   public void testE2EExecutionTaskFailedNoSoAndStatusResponse() throws Exception {
 497
 498     ExecutionTask executionTaskA =
 499         ServiceOrderExecutionTaskAssertions.setUpBddForE2EExecutionTaskSucess(
 500             serviceOrderRepository, executionTaskRepository, ActionType.ADD);
 501
 502     Context.removeWireMockMapping("/onap/so/infra/e2eServiceInstances/v3");
 503     Context.removeWireMockMapping(
 504         "/onap/so/infra/e2eServiceInstances/v3/serviceId/operations/operationId");
 505
 506
 507     SoTaskProcessor.processOrderItem(executionTaskA);
 508     ServiceOrder serviceOrderChecked = getServiceOrder("test");
 509     assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
 510     for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 511       assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 512     }
 513
 514     assertThat(executionTaskRepository.count()).isEqualTo(0);
 515
 516   }
 517
 518
 519   @Test
 520   public void testExecutionTaskFailedBadRequestSo() throws Exception {
 521
 522     ExecutionTask executionTaskA =
 523         ServiceOrderExecutionTaskAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 524             executionTaskRepository, ActionType.ADD);
 525
 526
 527     changeWireMockResponse("/onap/so/infra/serviceInstantiation/v7/serviceInstances/", 400,
 528         "\"serviceException\": {\n" + "        \"messageId\": \"SVC0002\",\n"
 529             + "        \"text\": \"Error parsing request.  org.openecomp.mso.apihandler.common.ValidationException: serviceInstance already existsd\"\n"
 530             + "    }");
 531
 532
 533     SoTaskProcessor.processOrderItem(executionTaskA);
 534     ServiceOrder serviceOrderChecked = getServiceOrder("test");
 535     assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
 536     for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 537       assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 538     }
 539
 540     assertThat(executionTaskRepository.count()).isEqualTo(0);
 541
 542     for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 543       if (serviceOrderItem.getId().equals("A")) {
 544         assertThat(serviceOrderItem.getOrderItemMessage().size()).isEqualTo(1);
 545         assertThat(serviceOrderItem.getOrderItemMessage().get(0).getCode()).isEqualTo("105");
 546         assertThat(serviceOrderItem.getOrderItemMessage().get(0).getField())
 547             .isEqualTo("service.name");
 548       }
 549     }
 550
 551   }
 552
 553
 554   @Test
 555   public void testExecutionTaskModifySuccess() throws Exception {
 556
 557     ExecutionTask executionTaskA =
 558         ServiceOrderExecutionTaskAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 559             executionTaskRepository, ActionType.MODIFY);
 560     ExecutionTask executionTaskB;
 561
 562
 563     SoTaskProcessor.processOrderItem(executionTaskA);
 564     ServiceOrder serviceOrderChecked = getServiceOrder("test");
 565     assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 566     for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 567       if (serviceOrderItem.getId().equals("A")) {
 568         // assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS);
 569         assertThat(serviceOrderItem.getState())
 570             .isEqualTo(StateType.INPROGRESS_MODIFY_ITEM_TO_CREATE);
 571       } else {
 572         assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 573       }
 574     }
 575     SoTaskProcessor.processOrderItem(executionTaskA);
 576     serviceOrderChecked = getServiceOrder("test");
 577     assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 578     for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 579       if (serviceOrderItem.getId().equals("A")) {
 580         assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 581       } else {
 582         assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 583       }
 584     }
 585
 586     executionTaskB = getExecutionTask("B");
 587     assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 588     executionTaskA = getExecutionTask("A");
 589     assertThat(executionTaskA).isNull();
 590
 591     SoTaskProcessor.processOrderItem(executionTaskB);
 592     SoTaskProcessor.processOrderItem(executionTaskB);
 593
 594     serviceOrderChecked = getServiceOrder("test");
 595     assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 596     for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 597       assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 598
 599     }
 600
 601     assertThat(executionTaskRepository.count()).isEqualTo(0);
 602
 603   }
 604
 605
 606
 607   @Test
 608   public void testExecutionTaskModifyFailed() throws Exception {
 609
 610     ExecutionTask executionTaskA =
 611         ServiceOrderExecutionTaskAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 612             executionTaskRepository, ActionType.MODIFY);
 613     ExecutionTask executionTaskB;
 614     Context.removeWireMockMapping("/onap/so/infra/orchestrationRequests/v7/requestId");
 615
 616
 617     SoTaskProcessor.processOrderItem(executionTaskA);
 618     ServiceOrder serviceOrderChecked = getServiceOrder("test");
 619     assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 620     for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 621       if (serviceOrderItem.getId().equals("A")) {
 622         // assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS);
 623         assertThat(serviceOrderItem.getState())
 624             .isEqualTo(StateType.INPROGRESS_MODIFY_REQUEST_DELETE_SEND);
 625       } else {
 626         assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 627       }
 628     }
 629     executionTaskA = getExecutionTask("A");
 630     assertThat(
 631         executionTaskA.getLastAttemptDate().getTime() > executionTaskA.getCreateDate().getTime())
 632             .isTrue();
 633     changeCreationDate(executionTaskA);
 634     SoTaskProcessor.processOrderItem(executionTaskA);
 635
 636     serviceOrderChecked = getServiceOrder("test");
 637     assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
 638     for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 639       assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 640
 641     }
 642
 643     assertThat(executionTaskRepository.count()).isEqualTo(0);
 644
 645   }
 646
 647   @Test
 648   public void testExecutionTaskWithoutOnap() throws Exception {
 649     Context.stopWiremock();
 650     ExecutionTask executionTaskA =
 651         ServiceOrderExecutionTaskAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 652             executionTaskRepository, ActionType.ADD);
 653
 654     SoTaskProcessor.processOrderItem(executionTaskA);
 655     ServiceOrder serviceOrderChecked = getServiceOrder("test");
 656     assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
 657     for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 658       assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 659     }
 660     assertThat(serviceOrderChecked.getOrderMessage().size()).isGreaterThan(0);
 661     assertThat(serviceOrderChecked.getOrderMessage().get(0).getCode()).isEqualTo("502");
 662     assertThat(serviceOrderChecked.getOrderMessage().get(0).getMessageInformation())
 663         .isEqualTo("Problem with SO API");
 664
 665     assertThat(executionTaskRepository.count()).isEqualTo(0);
 666     Context.startWiremock();
 667
 668   }
 669
 670 }