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