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");
   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.test;
  17
  18
  19 import static org.assertj.core.api.Assertions.assertThat;
  20
  21 import com.github.tomakehurst.wiremock.admin.model.ListStubMappingsResult;
  22 import com.github.tomakehurst.wiremock.http.ResponseDefinition;
  23 import com.github.tomakehurst.wiremock.stubbing.StubMapping;
  24 import java.util.Calendar;
  25 import java.util.Date;
  26 import java.util.List;
  27 import java.util.Optional;
  28 import javax.validation.Validation;
  29 import javax.validation.Validator;
  30 import javax.validation.ValidatorFactory;
  31 import org.junit.After;
  32 import org.junit.AfterClass;
  33 import org.junit.Before;
  34 import org.junit.BeforeClass;
  35 import org.junit.Test;
  36 import org.junit.runner.RunWith;
  37 import org.onap.nbi.apis.assertions.ServiceOrderExecutionTaskAssertions;
  38 import org.onap.nbi.apis.serviceorder.model.ActionType;
  39 import org.onap.nbi.apis.serviceorder.model.ServiceOrder;
  40 import org.onap.nbi.apis.serviceorder.model.ServiceOrderItem;
  41 import org.onap.nbi.apis.serviceorder.model.StateType;
  42 import org.onap.nbi.apis.serviceorder.model.orchestrator.ExecutionTask;
  43 import org.onap.nbi.apis.serviceorder.repositories.ExecutionTaskRepository;
  44 import org.onap.nbi.apis.serviceorder.repositories.ServiceOrderRepository;
  45 import org.onap.nbi.apis.serviceorder.workflow.SOTaskProcessor;
  46 import org.springframework.beans.factory.annotation.Autowired;
  47 import org.springframework.boot.test.context.SpringBootTest;
  48 import org.springframework.mock.web.MockHttpServletRequest;
  49 import org.springframework.test.annotation.DirtiesContext;
  50 import org.springframework.test.annotation.DirtiesContext.ClassMode;
  51 import org.springframework.test.context.ActiveProfiles;
  52 import org.springframework.test.context.junit4.SpringRunner;
  53 import org.springframework.web.context.request.RequestContextHolder;
  54 import org.springframework.web.context.request.ServletRequestAttributes;
  55
  56 @RunWith(SpringRunner.class)
  57 @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
  58 @ActiveProfiles("test")
  59 @DirtiesContext(classMode= ClassMode.AFTER_CLASS)
  60 public class ExecutionTaskTest {
  61
  62     @Autowired
  63     ServiceOrderRepository serviceOrderRepository;
  64
  65     @Autowired
  66     ExecutionTaskRepository executionTaskRepository;
  67
  68     @Autowired
  69     SOTaskProcessor SoTaskProcessor;
  70
  71
  72     static Validator validator;
  73
  74     @Before
  75     public void before() {
  76         MockHttpServletRequest request = new MockHttpServletRequest();
  77         RequestContextHolder.setRequestAttributes(new ServletRequestAttributes(request));
  78     }
  79
  80     @BeforeClass
  81     public static void setUp() throws Exception {
  82         ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
  83         validator = factory.getValidator();
  84         Context.startWiremock();
  85     }
  86
  87     @AfterClass
  88     public static void tearsDown() throws Exception {
  89         Context.stopServers();
  90
  91     }
  92
  93     @After
  94     public void tearsDownUpPort() throws Exception {
  95         executionTaskRepository.deleteAll();
  96         serviceOrderRepository.deleteAll();
  97         Context.wireMockServer.resetToDefaultMappings();
  98
  99     }
 100
 101
 102     public ExecutionTask getExecutionTask(String orderItemId) {
 103         for (ExecutionTask executionTask : executionTaskRepository.findAll()) {
 104             if (executionTask.getOrderItemId().equalsIgnoreCase(orderItemId)) {
 105                 return executionTask;
 106             }
 107
 108         }
 109         return null;
 110     }
 111
 112     private void changeWireMockResponse(String s,int statusCode, String bodyContent) {
 113         ListStubMappingsResult listStubMappingsResult = Context.wireMockServer.listAllStubMappings();
 114         ResponseDefinition responseDefinition = new ResponseDefinition(statusCode,bodyContent);
 115         List<StubMapping> mappings = listStubMappingsResult.getMappings();
 116         for (StubMapping mapping : mappings) {
 117             if (mapping.getRequest().getUrl().equals(s)) {
 118                 mapping.setResponse(responseDefinition);
 119             }
 120         }
 121     }
 122
 123
 124     private ServiceOrder getServiceOrder(String serviceOrderId) {
 125         Optional<ServiceOrder> serviceOrderChecked = serviceOrderRepository.findById(serviceOrderId);
 126         return serviceOrderChecked.get();
 127     }
 128
 129
 130
 131     @Test
 132     public void testExecutionTaskSuccess() throws Exception {
 133
 134         ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 135             executionTaskRepository, ActionType.ADD);
 136         ExecutionTask executionTaskB;
 137
 138
 139         SoTaskProcessor.processOrderItem(executionTaskA);
 140         ServiceOrder serviceOrderChecked = getServiceOrder("test");
 141         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 142         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 143             if (serviceOrderItem.getId().equals("A")) {
 144                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 145             } else {
 146                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 147             }
 148         }
 149
 150         executionTaskB = getExecutionTask("B");
 151         assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 152         executionTaskA = getExecutionTask("A");
 153         assertThat(executionTaskA).isNull();
 154
 155         SoTaskProcessor.processOrderItem(executionTaskB);
 156         serviceOrderChecked = getServiceOrder("test");
 157         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 158         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 159             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 160
 161         }
 162
 163         assertThat(executionTaskRepository.count()).isEqualTo(0);
 164
 165
 166
 167     }
 168
 169     @Test
 170     public void testE2EExecutionTaskSuccess() throws Exception {
 171
 172         ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions.setUpBddForE2EExecutionTaskSucess(serviceOrderRepository,
 173             executionTaskRepository, ActionType.ADD);
 174         ExecutionTask executionTaskB;
 175
 176
 177         SoTaskProcessor.processOrderItem(executionTaskA);
 178         ServiceOrder serviceOrderChecked = getServiceOrder("test");
 179         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 180         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 181             if (serviceOrderItem.getId().equals("A")) {
 182                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 183             } else {
 184                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 185             }
 186         }
 187
 188         executionTaskB = getExecutionTask("B");
 189         assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 190         executionTaskA = getExecutionTask("A");
 191         assertThat(executionTaskA).isNull();
 192
 193         SoTaskProcessor.processOrderItem(executionTaskB);
 194         serviceOrderChecked = getServiceOrder("test");
 195         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 196         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 197             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 198
 199         }
 200
 201         assertThat(executionTaskRepository.count()).isEqualTo(0);
 202
 203
 204
 205     }
 206
 207     @Test
 208     public void testExecutionTaskDeleteSuccess() throws Exception {
 209
 210         ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 211             executionTaskRepository, ActionType.DELETE);
 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 testE2EExecutionTaskDeleteSuccess() throws Exception {
 247
 248         ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions.setUpBddForE2EExecutionTaskSucess(serviceOrderRepository,
 249             executionTaskRepository, ActionType.DELETE);
 250         ExecutionTask executionTaskB;
 251
 252
 253         SoTaskProcessor.processOrderItem(executionTaskA);
 254         ServiceOrder serviceOrderChecked = getServiceOrder("test");
 255         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 256         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 257             if (serviceOrderItem.getId().equals("A")) {
 258                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 259             } else {
 260                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 261             }
 262         }
 263
 264         executionTaskB = getExecutionTask("B");
 265         assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 266         executionTaskA = getExecutionTask("A");
 267         assertThat(executionTaskA).isNull();
 268
 269         SoTaskProcessor.processOrderItem(executionTaskB);
 270         serviceOrderChecked = getServiceOrder("test");
 271         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 272         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 273             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 274
 275         }
 276
 277         assertThat(executionTaskRepository.count()).isEqualTo(0);
 278
 279
 280
 281     }
 282
 283
 284     @Test
 285     public void testExecutionTaskFailed() throws Exception {
 286
 287         ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 288             executionTaskRepository, ActionType.ADD);
 289
 290         Context.removeWireMockMapping("/onap/so/infra/orchestrationRequests/v7/requestId");
 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.INPROGRESS);
 299             } else {
 300                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 301             }
 302         }
 303         executionTaskA = getExecutionTask("A");
 304         Date createDate = executionTaskA.getCreateDate();
 305         assertThat(executionTaskA.getLastAttemptDate().getTime()> createDate.getTime()).isTrue();
 306
 307         changeCreationDate(executionTaskA);
 308         SoTaskProcessor.processOrderItem(executionTaskA);
 309
 310         serviceOrderChecked = getServiceOrder("test");
 311         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
 312         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 313             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 314
 315         }
 316
 317         assertThat(executionTaskRepository.count()).isEqualTo(0);
 318
 319
 320     }
 321
 322     private void changeCreationDate(ExecutionTask executionTaskA) {
 323         Calendar cal = Calendar.getInstance();
 324         cal.setTime(executionTaskA.getCreateDate());
 325         cal.add(Calendar.SECOND, -30);
 326         executionTaskA.setCreateDate(cal.getTime());
 327     }
 328
 329
 330     @Test
 331     public void testE2EExecutionTaskFailed() throws Exception {
 332
 333         ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions.setUpBddForE2EExecutionTaskSucess(serviceOrderRepository,
 334             executionTaskRepository, ActionType.ADD);
 335
 336         Context.removeWireMockMapping("/onap/so/infra/e2eServiceInstances/v3/serviceId/operations/operationId");
 337
 338
 339         SoTaskProcessor.processOrderItem(executionTaskA);
 340         ServiceOrder serviceOrderChecked = getServiceOrder("test");
 341         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 342         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 343             if (serviceOrderItem.getId().equals("A")) {
 344                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS);
 345             } else {
 346                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 347             }
 348         }
 349         executionTaskA = getExecutionTask("A");
 350         assertThat(executionTaskA.getLastAttemptDate().getTime()>executionTaskA.getCreateDate().getTime()).isTrue();
 351         changeCreationDate(executionTaskA);
 352         SoTaskProcessor.processOrderItem(executionTaskA);
 353
 354         serviceOrderChecked = getServiceOrder("test");
 355         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
 356         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 357             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 358
 359         }
 360
 361         assertThat(executionTaskRepository.count()).isEqualTo(0);
 362
 363
 364     }
 365
 366     @Test
 367     public void testExecutionTaskFailedNoSoResponse() throws Exception {
 368
 369         ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 370             executionTaskRepository, ActionType.ADD);
 371
 372         Context.removeWireMockMapping("/onap/so/infra/serviceInstantiation/v7/serviceInstances/");
 373
 374
 375         SoTaskProcessor.processOrderItem(executionTaskA);
 376         ServiceOrder serviceOrderChecked = getServiceOrder("test");
 377         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
 378         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 379             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 380         }
 381
 382         assertThat(executionTaskRepository.count()).isEqualTo(0);
 383
 384
 385
 386     }
 387
 388     @Test
 389     public void testExecutionTaskFailedNoSoAndStatusResponse() throws Exception {
 390
 391         ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 392             executionTaskRepository, ActionType.ADD);
 393
 394         Context.removeWireMockMapping("/onap/so/infra/serviceInstantiation/v7/serviceInstances/");
 395         Context.removeWireMockMapping("/onap/so/infra/orchestrationRequests/v7/requestId");
 396
 397
 398         SoTaskProcessor.processOrderItem(executionTaskA);
 399         ServiceOrder serviceOrderChecked = getServiceOrder("test");
 400         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
 401         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 402             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 403         }
 404
 405         assertThat(executionTaskRepository.count()).isEqualTo(0);
 406
 407     }
 408
 409     @Test
 410     public void testE2EExecutionTaskFailedNoSoAndStatusResponse() throws Exception {
 411
 412         ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions.setUpBddForE2EExecutionTaskSucess(serviceOrderRepository,
 413             executionTaskRepository, ActionType.ADD);
 414
 415         Context.removeWireMockMapping("/onap/so/infra/e2eServiceInstances/v3");
 416         Context.removeWireMockMapping("/onap/so/infra/e2eServiceInstances/v3/serviceId/operations/operationId");
 417
 418
 419         SoTaskProcessor.processOrderItem(executionTaskA);
 420         ServiceOrder serviceOrderChecked = getServiceOrder("test");
 421         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
 422         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 423             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 424         }
 425
 426         assertThat(executionTaskRepository.count()).isEqualTo(0);
 427
 428     }
 429
 430
 431     @Test
 432     public void testExecutionTaskFailedBadRequestSo() throws Exception {
 433
 434         ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 435             executionTaskRepository, ActionType.ADD);
 436
 437
 438         changeWireMockResponse("/onap/so/infra/serviceInstantiation/v7/serviceInstances/",400,"\"serviceException\": {\n"
 439             + "        \"messageId\": \"SVC0002\",\n"
 440             + "        \"text\": \"Error parsing request.  org.openecomp.mso.apihandler.common.ValidationException: serviceInstance already existsd\"\n"
 441             + "    }");
 442
 443
 444         SoTaskProcessor.processOrderItem(executionTaskA);
 445         ServiceOrder serviceOrderChecked = getServiceOrder("test");
 446         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
 447         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 448             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 449         }
 450
 451         assertThat(executionTaskRepository.count()).isEqualTo(0);
 452
 453         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 454             if(serviceOrderItem.getId().equals("A")) {
 455                 assertThat(serviceOrderItem.getOrderItemMessage().size()).isEqualTo(1);
 456                 assertThat(serviceOrderItem.getOrderItemMessage().get(0).getCode()).isEqualTo("105");
 457                 assertThat(serviceOrderItem.getOrderItemMessage().get(0).getField()).isEqualTo("service.name");
 458             }
 459         }
 460
 461     }
 462
 463
 464     @Test
 465     public void testExecutionTaskModifySuccess() throws Exception {
 466
 467         ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 468             executionTaskRepository, ActionType.MODIFY);
 469         ExecutionTask executionTaskB;
 470
 471
 472         SoTaskProcessor.processOrderItem(executionTaskA);
 473         ServiceOrder serviceOrderChecked = getServiceOrder("test");
 474         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 475         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 476             if (serviceOrderItem.getId().equals("A")) {
 477                 //assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS);
 478                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS_MODIFY_ITEM_TO_CREATE);
 479             } else {
 480                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 481             }
 482         }
 483         SoTaskProcessor.processOrderItem(executionTaskA);
 484         serviceOrderChecked = getServiceOrder("test");
 485         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 486         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 487             if (serviceOrderItem.getId().equals("A")) {
 488                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 489             } else {
 490                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 491             }
 492         }
 493
 494         executionTaskB = getExecutionTask("B");
 495         assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
 496         executionTaskA = getExecutionTask("A");
 497         assertThat(executionTaskA).isNull();
 498
 499         SoTaskProcessor.processOrderItem(executionTaskB);
 500         SoTaskProcessor.processOrderItem(executionTaskB);
 501
 502         serviceOrderChecked = getServiceOrder("test");
 503         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
 504         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 505             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 506
 507         }
 508
 509         assertThat(executionTaskRepository.count()).isEqualTo(0);
 510
 511     }
 512
 513
 514
 515
 516     @Test
 517     public void testExecutionTaskModifyFailed() throws Exception {
 518
 519         ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 520             executionTaskRepository, ActionType.MODIFY);
 521         ExecutionTask executionTaskB;
 522         Context.removeWireMockMapping("/onap/so/infra/orchestrationRequests/v7/requestId");
 523
 524
 525         SoTaskProcessor.processOrderItem(executionTaskA);
 526         ServiceOrder serviceOrderChecked = getServiceOrder("test");
 527         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
 528         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 529             if (serviceOrderItem.getId().equals("A")) {
 530                 //assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS);
 531                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS_MODIFY_REQUEST_DELETE_SEND);
 532             } else {
 533                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
 534             }
 535         }
 536         executionTaskA = getExecutionTask("A");
 537         assertThat(executionTaskA.getLastAttemptDate().getTime()>executionTaskA.getCreateDate().getTime()).isTrue();
 538         changeCreationDate(executionTaskA);
 539         SoTaskProcessor.processOrderItem(executionTaskA);
 540
 541         serviceOrderChecked = getServiceOrder("test");
 542         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
 543         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 544             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 545
 546         }
 547
 548         assertThat(executionTaskRepository.count()).isEqualTo(0);
 549
 550     }
 551
 552     @Test
 553     public void testExecutionTaskWithoutOnap() throws Exception {
 554         Context.stopWiremock();
 555         ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
 556             executionTaskRepository, ActionType.ADD);
 557
 558         SoTaskProcessor.processOrderItem(executionTaskA);
 559         ServiceOrder serviceOrderChecked = getServiceOrder("test");
 560         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
 561         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
 562             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 563         }
 564         assertThat(serviceOrderChecked.getOrderMessage().size()).isGreaterThan(0);
 565         assertThat(serviceOrderChecked.getOrderMessage().get(0).getCode()).isEqualTo("502");
 566         assertThat(serviceOrderChecked.getOrderMessage().get(0).getMessageInformation()).isEqualTo("Problem with SO API");
 567
 568         assertThat(executionTaskRepository.count()).isEqualTo(0);
 569         Context.startWiremock();
 570
 571     }
 572
 573 }