gerrit.onap Code Review - so.git/blob

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP - SO
   4  * ================================================================================
   5  * Copyright (C) 2017 - 2018 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.so.bpmn.servicedecomposition.tasks;
  22
  23 import static org.junit.Assert.assertEquals;
  24 import static org.mockito.ArgumentMatchers.eq;
  25 import static org.mockito.ArgumentMatchers.isA;
  26 import static org.mockito.Mockito.doReturn;
  27 import static org.mockito.Mockito.doThrow;
  28 import static org.mockito.Mockito.mock;
  29 import static org.mockito.Mockito.when;
  30 import org.camunda.bpm.engine.delegate.BpmnError;
  31 import org.camunda.bpm.engine.delegate.DelegateExecution;
  32 import org.junit.Before;
  33 import org.junit.Test;
  34 import org.onap.so.BaseTest;
  35 import org.onap.so.bpmn.core.WorkflowException;
  36 import org.onap.so.bpmn.servicedecomposition.bbobjects.Customer;
  37 import org.onap.so.bpmn.servicedecomposition.bbobjects.GenericVnf;
  38 import org.onap.so.bpmn.servicedecomposition.bbobjects.ServiceInstance;
  39 import org.onap.so.bpmn.servicedecomposition.entities.BuildingBlock;
  40 import org.onap.so.bpmn.servicedecomposition.entities.ExecuteBuildingBlock;
  41 import org.onap.so.constants.Status;
  42 import org.onap.so.db.catalog.beans.macro.RainyDayHandlerStatus;
  43 import org.springframework.beans.factory.annotation.Autowired;
  44
  45 public class ExecuteBuildingBlockRainyDayTest extends BaseTest {
  46     @Autowired
  47     private ExecuteBuildingBlockRainyDay executeBuildingBlockRainyDay;
  48
  49     private ServiceInstance serviceInstance;
  50     private Customer customer; // will build service sub
  51     private GenericVnf vnf;
  52     private static final String ASTERISK = "*";
  53
  54     @Before
  55     public void before() {
  56         serviceInstance = setServiceInstance();
  57         customer = setCustomer();
  58         vnf = setGenericVnf();
  59
  60         BuildingBlock buildingBlock = new BuildingBlock().setBpmnFlowName("AssignServiceInstanceBB");
  61         ExecuteBuildingBlock executeBuildingBlock = new ExecuteBuildingBlock();
  62         executeBuildingBlock.setBuildingBlock(buildingBlock);
  63
  64         delegateExecution.setVariable("gBBInput", gBBInput);
  65         delegateExecution.setVariable("WorkflowException", new WorkflowException("", 7000, ""));
  66         delegateExecution.setVariable("buildingBlock", executeBuildingBlock);
  67         delegateExecution.setVariable("lookupKeyMap", lookupKeyMap);
  68
  69         delegateExecution.setVariable("WorkflowException", new WorkflowException("processKey", 7000, "errorMessage"));
  70     }
  71
  72     @Test
  73     public void setRetryTimerTest() throws Exception {
  74         delegateExecution.setVariable("retryCount", 2);
  75         executeBuildingBlockRainyDay.setRetryTimer(delegateExecution);
  76         assertEquals("PT40S", delegateExecution.getVariable("RetryDuration"));
  77     }
  78
  79     @Test
  80     public void setRetryTimerExceptionTest() {
  81         expectedException.expect(BpmnError.class);
  82         DelegateExecution execution = mock(DelegateExecution.class);
  83         when(execution.getVariable(eq("retryCount"))).thenThrow(BpmnError.class);
  84         executeBuildingBlockRainyDay.setRetryTimer(execution);
  85     }
  86
  87     @Test
  88     public void queryRainyDayTableExists() throws Exception {
  89         customer.getServiceSubscription().getServiceInstances().add(serviceInstance);
  90         serviceInstance.getModelInfoServiceInstance().setServiceType("st1");
  91         vnf.setVnfType("vnft1");
  92         delegateExecution.setVariable("aLaCarte", true);
  93         delegateExecution.setVariable("suppressRollback", false);
  94         delegateExecution.setVariable("WorkflowExceptionCode", "7000");
  95         RainyDayHandlerStatus rainyDayHandlerStatus = new RainyDayHandlerStatus();
  96         rainyDayHandlerStatus.setErrorCode("7000");
  97         rainyDayHandlerStatus.setFlowName("AssignServiceInstanceBB");
  98         rainyDayHandlerStatus.setServiceType("st1");
  99         rainyDayHandlerStatus.setVnfType("vnft1");
 100         rainyDayHandlerStatus.setPolicy("Rollback");
 101         rainyDayHandlerStatus.setWorkStep(ASTERISK);
 102
 103         doReturn(rainyDayHandlerStatus).when(MOCK_catalogDbClient).getRainyDayHandlerStatus("AssignServiceInstanceBB",
 104                 "st1", "vnft1", "7000", "*", "errorMessage", "*");
 105
 106         executeBuildingBlockRainyDay.queryRainyDayTable(delegateExecution, true);
 107         assertEquals("Rollback", delegateExecution.getVariable("handlingCode"));
 108     }
 109
 110     @Test
 111     public void queryRainyDayTableDefault() throws Exception {
 112         customer.getServiceSubscription().getServiceInstances().add(serviceInstance);
 113         serviceInstance.getModelInfoServiceInstance().setServiceType("st1");
 114         vnf.setVnfType("vnft1");
 115         delegateExecution.setVariable("aLaCarte", true);
 116         delegateExecution.setVariable("suppressRollback", false);
 117         delegateExecution.setVariable("WorkflowExceptionCode", ASTERISK);
 118         RainyDayHandlerStatus rainyDayHandlerStatus = new RainyDayHandlerStatus();
 119         rainyDayHandlerStatus.setErrorCode(ASTERISK);
 120         rainyDayHandlerStatus.setFlowName("AssignServiceInstanceBB");
 121         rainyDayHandlerStatus.setServiceType(ASTERISK);
 122         rainyDayHandlerStatus.setVnfType(ASTERISK);
 123         rainyDayHandlerStatus.setPolicy("Rollback");
 124         rainyDayHandlerStatus.setWorkStep(ASTERISK);
 125
 126         doReturn(rainyDayHandlerStatus).when(MOCK_catalogDbClient).getRainyDayHandlerStatus("AssignServiceInstanceBB",
 127                 "st1", "vnft1", ASTERISK, ASTERISK, "errorMessage", "*");
 128         executeBuildingBlockRainyDay.queryRainyDayTable(delegateExecution, true);
 129         assertEquals("Rollback", delegateExecution.getVariable("handlingCode"));
 130         assertEquals(5, delegateExecution.getVariable("maxRetries"));
 131     }
 132
 133     @Test
 134     public void queryRainyDayTableDoesNotExist() throws Exception {
 135         customer.getServiceSubscription().getServiceInstances().add(serviceInstance);
 136         serviceInstance.getModelInfoServiceInstance().setServiceType("st1");
 137         vnf.setVnfType("vnft1");
 138         delegateExecution.setVariable("aLaCarte", true);
 139         doReturn(null).when(MOCK_catalogDbClient).getRainyDayHandlerStatus(isA(String.class), isA(String.class),
 140                 isA(String.class), isA(String.class), isA(String.class), isA(String.class), isA(String.class));
 141         delegateExecution.setVariable("suppressRollback", false);
 142
 143         executeBuildingBlockRainyDay.queryRainyDayTable(delegateExecution, true);
 144
 145         assertEquals("Abort", delegateExecution.getVariable("handlingCode"));
 146     }
 147
 148     @Test
 149     public void queryRainyDayTableExceptionTest() {
 150         doThrow(RuntimeException.class).when(MOCK_catalogDbClient).getRainyDayHandlerStatus(isA(String.class),
 151                 isA(String.class), isA(String.class), isA(String.class), isA(String.class), isA(String.class),
 152                 isA(String.class));
 153         delegateExecution.setVariable("aLaCarte", true);
 154         executeBuildingBlockRainyDay.queryRainyDayTable(delegateExecution, true);
 155         delegateExecution.setVariable("suppressRollback", false);
 156
 157         assertEquals("Abort", delegateExecution.getVariable("handlingCode"));
 158     }
 159
 160     @Test
 161     public void queryRainyDayTableSecondaryPolicyExists() throws Exception {
 162         customer.getServiceSubscription().getServiceInstances().add(serviceInstance);
 163         serviceInstance.getModelInfoServiceInstance().setServiceType("st1");
 164         vnf.setVnfType("vnft1");
 165         delegateExecution.setVariable("aLaCarte", true);
 166         delegateExecution.setVariable("suppressRollback", false);
 167         delegateExecution.setVariable("WorkflowExceptionCode", "7000");
 168         RainyDayHandlerStatus rainyDayHandlerStatus = new RainyDayHandlerStatus();
 169         rainyDayHandlerStatus.setErrorCode("7000");
 170         rainyDayHandlerStatus.setFlowName("AssignServiceInstanceBB");
 171         rainyDayHandlerStatus.setServiceType("st1");
 172         rainyDayHandlerStatus.setVnfType("vnft1");
 173         rainyDayHandlerStatus.setPolicy("Retry");
 174         rainyDayHandlerStatus.setWorkStep(ASTERISK);
 175         rainyDayHandlerStatus.setSecondaryPolicy("Abort");
 176
 177         doReturn(rainyDayHandlerStatus).when(MOCK_catalogDbClient).getRainyDayHandlerStatus("AssignServiceInstanceBB",
 178                 "st1", "vnft1", "7000", "*", "errorMessage", "*");
 179
 180         executeBuildingBlockRainyDay.queryRainyDayTable(delegateExecution, false);
 181
 182         assertEquals("Abort", delegateExecution.getVariable("handlingCode"));
 183     }
 184
 185     @Test
 186     public void queryRainyDayTableRollbackToAssignedMacro() throws Exception {
 187         customer.getServiceSubscription().getServiceInstances().add(serviceInstance);
 188         serviceInstance.getModelInfoServiceInstance().setServiceType("st1");
 189         vnf.setVnfType("vnft1");
 190         delegateExecution.setVariable("aLaCarte", false);
 191         delegateExecution.setVariable("suppressRollback", false);
 192         delegateExecution.setVariable("WorkflowExceptionCode", "7000");
 193         RainyDayHandlerStatus rainyDayHandlerStatus = new RainyDayHandlerStatus();
 194         rainyDayHandlerStatus.setErrorCode("7000");
 195         rainyDayHandlerStatus.setFlowName("AssignServiceInstanceBB");
 196         rainyDayHandlerStatus.setServiceType("st1");
 197         rainyDayHandlerStatus.setVnfType("vnft1");
 198         rainyDayHandlerStatus.setPolicy("RollbackToAssigned");
 199         rainyDayHandlerStatus.setWorkStep(ASTERISK);
 200         rainyDayHandlerStatus.setSecondaryPolicy("Abort");
 201
 202         doReturn(rainyDayHandlerStatus).when(MOCK_catalogDbClient).getRainyDayHandlerStatus("AssignServiceInstanceBB",
 203                 "st1", "vnft1", "7000", "*", "errorMessage", "*");
 204
 205         executeBuildingBlockRainyDay.queryRainyDayTable(delegateExecution, true);
 206
 207         assertEquals("Rollback", delegateExecution.getVariable("handlingCode"));
 208         assertEquals(Status.ROLLED_BACK.toString(), delegateExecution.getVariable("rollbackTargetState"));
 209     }
 210
 211     @Test
 212     public void queryRainyDayTableRollbackToAssignedALaCarte() throws Exception {
 213         customer.getServiceSubscription().getServiceInstances().add(serviceInstance);
 214         serviceInstance.getModelInfoServiceInstance().setServiceType("st1");
 215         vnf.setVnfType("vnft1");
 216         delegateExecution.setVariable("aLaCarte", true);
 217         delegateExecution.setVariable("suppressRollback", false);
 218         delegateExecution.setVariable("WorkflowExceptionCode", "7000");
 219         RainyDayHandlerStatus rainyDayHandlerStatus = new RainyDayHandlerStatus();
 220         rainyDayHandlerStatus.setErrorCode("7000");
 221         rainyDayHandlerStatus.setFlowName("AssignServiceInstanceBB");
 222         rainyDayHandlerStatus.setServiceType("st1");
 223         rainyDayHandlerStatus.setVnfType("vnft1");
 224         rainyDayHandlerStatus.setPolicy("RollbackToAssigned");
 225         rainyDayHandlerStatus.setWorkStep(ASTERISK);
 226         rainyDayHandlerStatus.setSecondaryPolicy("Abort");
 227
 228         doReturn(rainyDayHandlerStatus).when(MOCK_catalogDbClient).getRainyDayHandlerStatus("AssignServiceInstanceBB",
 229                 "st1", "vnft1", "7000", "*", "errorMessage", "*");
 230
 231         executeBuildingBlockRainyDay.queryRainyDayTable(delegateExecution, true);
 232
 233         assertEquals("RollbackToAssigned", delegateExecution.getVariable("handlingCode"));
 234         assertEquals(Status.ROLLED_BACK_TO_ASSIGNED.toString(), delegateExecution.getVariable("rollbackTargetState"));
 235     }
 236
 237     @Test
 238     public void queryRainyDayTableRollbackToCreated() throws Exception {
 239         customer.getServiceSubscription().getServiceInstances().add(serviceInstance);
 240         serviceInstance.getModelInfoServiceInstance().setServiceType("st1");
 241         vnf.setVnfType("vnft1");
 242         delegateExecution.setVariable("aLaCarte", true);
 243         delegateExecution.setVariable("suppressRollback", false);
 244         delegateExecution.setVariable("WorkflowExceptionCode", "7000");
 245         RainyDayHandlerStatus rainyDayHandlerStatus = new RainyDayHandlerStatus();
 246         rainyDayHandlerStatus.setErrorCode("7000");
 247         rainyDayHandlerStatus.setFlowName("AssignServiceInstanceBB");
 248         rainyDayHandlerStatus.setServiceType("st1");
 249         rainyDayHandlerStatus.setVnfType("vnft1");
 250         rainyDayHandlerStatus.setPolicy("RollbackToCreated");
 251         rainyDayHandlerStatus.setWorkStep(ASTERISK);
 252         rainyDayHandlerStatus.setSecondaryPolicy("Abort");
 253
 254         doReturn(rainyDayHandlerStatus).when(MOCK_catalogDbClient).getRainyDayHandlerStatus("AssignServiceInstanceBB",
 255                 "st1", "vnft1", "7000", "*", "errorMessage", "*");
 256
 257         executeBuildingBlockRainyDay.queryRainyDayTable(delegateExecution, true);
 258
 259         assertEquals("RollbackToCreated", delegateExecution.getVariable("handlingCode"));
 260         assertEquals(Status.ROLLED_BACK_TO_CREATED.toString(), delegateExecution.getVariable("rollbackTargetState"));
 261     }
 262
 263
 264     @Test
 265     public void suppressRollbackTest() throws Exception {
 266         delegateExecution.setVariable("suppressRollback", true);
 267         delegateExecution.setVariable("aLaCarte", true);
 268         executeBuildingBlockRainyDay.queryRainyDayTable(delegateExecution, true);
 269         assertEquals("Abort", delegateExecution.getVariable("handlingCode"));
 270     }
 271
 272     @Test
 273     public void queryRainyDayTableServiceRoleNotDefined() throws Exception {
 274         customer.getServiceSubscription().getServiceInstances().add(serviceInstance);
 275         serviceInstance.getModelInfoServiceInstance().setServiceType("st1");
 276         serviceInstance.getModelInfoServiceInstance().setServiceRole("sr1");
 277         vnf.setVnfType("vnft1");
 278         delegateExecution.setVariable("aLaCarte", true);
 279         delegateExecution.setVariable("suppressRollback", false);
 280         delegateExecution.setVariable("WorkflowExceptionCode", "7000");
 281         RainyDayHandlerStatus rainyDayHandlerStatus = new RainyDayHandlerStatus();
 282         rainyDayHandlerStatus.setErrorCode("7000");
 283         rainyDayHandlerStatus.setFlowName("AssignServiceInstanceBB");
 284         rainyDayHandlerStatus.setServiceType("st1");
 285         rainyDayHandlerStatus.setVnfType("vnft1");
 286         rainyDayHandlerStatus.setPolicy("Rollback");
 287         rainyDayHandlerStatus.setWorkStep(ASTERISK);
 288
 289         doReturn(rainyDayHandlerStatus).when(MOCK_catalogDbClient).getRainyDayHandlerStatus("AssignServiceInstanceBB",
 290                 "st1", "vnft1", "7000", "*", "errorMessage", "sr1");
 291
 292         executeBuildingBlockRainyDay.queryRainyDayTable(delegateExecution, true);
 293         assertEquals("Rollback", delegateExecution.getVariable("handlingCode"));
 294     }
 295
 296     @Test
 297     public void queryRainyDayTableServiceRoleNC() throws Exception {
 298         customer.getServiceSubscription().getServiceInstances().add(serviceInstance);
 299         serviceInstance.getModelInfoServiceInstance().setServiceType("st1");
 300         serviceInstance.getModelInfoServiceInstance().setServiceRole("NETWORK-COLLECTION");
 301         vnf.setVnfType("vnft1");
 302         delegateExecution.setVariable("aLaCarte", true);
 303         delegateExecution.setVariable("suppressRollback", false);
 304         delegateExecution.setVariable("WorkflowExceptionCode", "7000");
 305         RainyDayHandlerStatus rainyDayHandlerStatus = new RainyDayHandlerStatus();
 306         rainyDayHandlerStatus.setErrorCode("7000");
 307         rainyDayHandlerStatus.setFlowName("ActivateServiceInstanceBB");
 308         rainyDayHandlerStatus.setServiceType("st1");
 309         rainyDayHandlerStatus.setVnfType("vnft1");
 310         rainyDayHandlerStatus.setPolicy("Abort");
 311         rainyDayHandlerStatus.setWorkStep(ASTERISK);
 312
 313         doReturn(rainyDayHandlerStatus).when(MOCK_catalogDbClient).getRainyDayHandlerStatus("AssignServiceInstanceBB",
 314                 "st1", "vnft1", "7000", "*", "errorMessage", "NETWORK-COLLECTION");
 315
 316         executeBuildingBlockRainyDay.queryRainyDayTable(delegateExecution, true);
 317         assertEquals("Abort", delegateExecution.getVariable("handlingCode"));
 318     }
 319
 320 }