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().setBuildingBlock(buildingBlock);
  62
  63         delegateExecution.setVariable("gBBInput", gBBInput);
  64         delegateExecution.setVariable("WorkflowException", new WorkflowException("", 7000, ""));
  65         delegateExecution.setVariable("buildingBlock", executeBuildingBlock);
  66         delegateExecution.setVariable("lookupKeyMap", lookupKeyMap);
  67
  68         delegateExecution.setVariable("WorkflowException", new WorkflowException("processKey", 7000, "errorMessage"));
  69     }
  70
  71     @Test
  72     public void setRetryTimerTest() throws Exception {
  73         delegateExecution.setVariable("retryCount", 2);
  74         executeBuildingBlockRainyDay.setRetryTimer(delegateExecution);
  75         assertEquals("PT40S", delegateExecution.getVariable("RetryDuration"));
  76     }
  77
  78     @Test
  79     public void setRetryTimerExceptionTest() {
  80         expectedException.expect(BpmnError.class);
  81         DelegateExecution execution = mock(DelegateExecution.class);
  82         when(execution.getVariable(eq("retryCount"))).thenThrow(BpmnError.class);
  83         executeBuildingBlockRainyDay.setRetryTimer(execution);
  84     }
  85
  86     @Test
  87     public void queryRainyDayTableExists() throws Exception {
  88         customer.getServiceSubscription().getServiceInstances().add(serviceInstance);
  89         serviceInstance.getModelInfoServiceInstance().setServiceType("st1");
  90         vnf.setVnfType("vnft1");
  91         delegateExecution.setVariable("aLaCarte", true);
  92         delegateExecution.setVariable("suppressRollback", false);
  93         delegateExecution.setVariable("WorkflowExceptionCode", "7000");
  94         RainyDayHandlerStatus rainyDayHandlerStatus = new RainyDayHandlerStatus();
  95         rainyDayHandlerStatus.setErrorCode("7000");
  96         rainyDayHandlerStatus.setFlowName("AssignServiceInstanceBB");
  97         rainyDayHandlerStatus.setServiceType("st1");
  98         rainyDayHandlerStatus.setVnfType("vnft1");
  99         rainyDayHandlerStatus.setPolicy("Rollback");
 100         rainyDayHandlerStatus.setWorkStep(ASTERISK);
 101
 102         doReturn(rainyDayHandlerStatus).when(MOCK_catalogDbClient).getRainyDayHandlerStatus("AssignServiceInstanceBB",
 103                 "st1", "vnft1", "7000", "*", "errorMessage", "*");
 104
 105         executeBuildingBlockRainyDay.queryRainyDayTable(delegateExecution, true);
 106         assertEquals("Rollback", delegateExecution.getVariable("handlingCode"));
 107     }
 108
 109     @Test
 110     public void queryRainyDayTableDefault() throws Exception {
 111         customer.getServiceSubscription().getServiceInstances().add(serviceInstance);
 112         serviceInstance.getModelInfoServiceInstance().setServiceType("st1");
 113         vnf.setVnfType("vnft1");
 114         delegateExecution.setVariable("aLaCarte", true);
 115         delegateExecution.setVariable("suppressRollback", false);
 116         delegateExecution.setVariable("WorkflowExceptionCode", ASTERISK);
 117         RainyDayHandlerStatus rainyDayHandlerStatus = new RainyDayHandlerStatus();
 118         rainyDayHandlerStatus.setErrorCode(ASTERISK);
 119         rainyDayHandlerStatus.setFlowName("AssignServiceInstanceBB");
 120         rainyDayHandlerStatus.setServiceType(ASTERISK);
 121         rainyDayHandlerStatus.setVnfType(ASTERISK);
 122         rainyDayHandlerStatus.setPolicy("Rollback");
 123         rainyDayHandlerStatus.setWorkStep(ASTERISK);
 124
 125         doReturn(rainyDayHandlerStatus).when(MOCK_catalogDbClient).getRainyDayHandlerStatus("AssignServiceInstanceBB",
 126                 "st1", "vnft1", ASTERISK, ASTERISK, "errorMessage", "*");
 127         executeBuildingBlockRainyDay.queryRainyDayTable(delegateExecution, true);
 128         assertEquals("Rollback", delegateExecution.getVariable("handlingCode"));
 129         assertEquals(5, delegateExecution.getVariable("maxRetries"));
 130     }
 131
 132     @Test
 133     public void queryRainyDayTableDoesNotExist() throws Exception {
 134         customer.getServiceSubscription().getServiceInstances().add(serviceInstance);
 135         serviceInstance.getModelInfoServiceInstance().setServiceType("st1");
 136         vnf.setVnfType("vnft1");
 137         delegateExecution.setVariable("aLaCarte", true);
 138         doReturn(null).when(MOCK_catalogDbClient).getRainyDayHandlerStatus(isA(String.class), isA(String.class),
 139                 isA(String.class), isA(String.class), isA(String.class), isA(String.class), isA(String.class));
 140         delegateExecution.setVariable("suppressRollback", false);
 141
 142         executeBuildingBlockRainyDay.queryRainyDayTable(delegateExecution, true);
 143
 144         assertEquals("Abort", delegateExecution.getVariable("handlingCode"));
 145     }
 146
 147     @Test
 148     public void queryRainyDayTableExceptionTest() {
 149         doThrow(RuntimeException.class).when(MOCK_catalogDbClient).getRainyDayHandlerStatus(isA(String.class),
 150                 isA(String.class), isA(String.class), isA(String.class), isA(String.class), isA(String.class),
 151                 isA(String.class));
 152         delegateExecution.setVariable("aLaCarte", true);
 153         executeBuildingBlockRainyDay.queryRainyDayTable(delegateExecution, true);
 154         delegateExecution.setVariable("suppressRollback", false);
 155
 156         assertEquals("Abort", delegateExecution.getVariable("handlingCode"));
 157     }
 158
 159     @Test
 160     public void queryRainyDayTableSecondaryPolicyExists() throws Exception {
 161         customer.getServiceSubscription().getServiceInstances().add(serviceInstance);
 162         serviceInstance.getModelInfoServiceInstance().setServiceType("st1");
 163         vnf.setVnfType("vnft1");
 164         delegateExecution.setVariable("aLaCarte", true);
 165         delegateExecution.setVariable("suppressRollback", false);
 166         delegateExecution.setVariable("WorkflowExceptionCode", "7000");
 167         RainyDayHandlerStatus rainyDayHandlerStatus = new RainyDayHandlerStatus();
 168         rainyDayHandlerStatus.setErrorCode("7000");
 169         rainyDayHandlerStatus.setFlowName("AssignServiceInstanceBB");
 170         rainyDayHandlerStatus.setServiceType("st1");
 171         rainyDayHandlerStatus.setVnfType("vnft1");
 172         rainyDayHandlerStatus.setPolicy("Retry");
 173         rainyDayHandlerStatus.setWorkStep(ASTERISK);
 174         rainyDayHandlerStatus.setSecondaryPolicy("Abort");
 175
 176         doReturn(rainyDayHandlerStatus).when(MOCK_catalogDbClient).getRainyDayHandlerStatus("AssignServiceInstanceBB",
 177                 "st1", "vnft1", "7000", "*", "errorMessage", "*");
 178
 179         executeBuildingBlockRainyDay.queryRainyDayTable(delegateExecution, false);
 180
 181         assertEquals("Abort", delegateExecution.getVariable("handlingCode"));
 182     }
 183
 184     @Test
 185     public void queryRainyDayTableRollbackToAssignedMacro() throws Exception {
 186         customer.getServiceSubscription().getServiceInstances().add(serviceInstance);
 187         serviceInstance.getModelInfoServiceInstance().setServiceType("st1");
 188         vnf.setVnfType("vnft1");
 189         delegateExecution.setVariable("aLaCarte", false);
 190         delegateExecution.setVariable("suppressRollback", false);
 191         delegateExecution.setVariable("WorkflowExceptionCode", "7000");
 192         RainyDayHandlerStatus rainyDayHandlerStatus = new RainyDayHandlerStatus();
 193         rainyDayHandlerStatus.setErrorCode("7000");
 194         rainyDayHandlerStatus.setFlowName("AssignServiceInstanceBB");
 195         rainyDayHandlerStatus.setServiceType("st1");
 196         rainyDayHandlerStatus.setVnfType("vnft1");
 197         rainyDayHandlerStatus.setPolicy("RollbackToAssigned");
 198         rainyDayHandlerStatus.setWorkStep(ASTERISK);
 199         rainyDayHandlerStatus.setSecondaryPolicy("Abort");
 200
 201         doReturn(rainyDayHandlerStatus).when(MOCK_catalogDbClient).getRainyDayHandlerStatus("AssignServiceInstanceBB",
 202                 "st1", "vnft1", "7000", "*", "errorMessage", "*");
 203
 204         executeBuildingBlockRainyDay.queryRainyDayTable(delegateExecution, true);
 205
 206         assertEquals("Rollback", delegateExecution.getVariable("handlingCode"));
 207         assertEquals(Status.ROLLED_BACK.toString(), delegateExecution.getVariable("rollbackTargetState"));
 208     }
 209
 210     @Test
 211     public void queryRainyDayTableRollbackToAssignedALaCarte() throws Exception {
 212         customer.getServiceSubscription().getServiceInstances().add(serviceInstance);
 213         serviceInstance.getModelInfoServiceInstance().setServiceType("st1");
 214         vnf.setVnfType("vnft1");
 215         delegateExecution.setVariable("aLaCarte", true);
 216         delegateExecution.setVariable("suppressRollback", false);
 217         delegateExecution.setVariable("WorkflowExceptionCode", "7000");
 218         RainyDayHandlerStatus rainyDayHandlerStatus = new RainyDayHandlerStatus();
 219         rainyDayHandlerStatus.setErrorCode("7000");
 220         rainyDayHandlerStatus.setFlowName("AssignServiceInstanceBB");
 221         rainyDayHandlerStatus.setServiceType("st1");
 222         rainyDayHandlerStatus.setVnfType("vnft1");
 223         rainyDayHandlerStatus.setPolicy("RollbackToAssigned");
 224         rainyDayHandlerStatus.setWorkStep(ASTERISK);
 225         rainyDayHandlerStatus.setSecondaryPolicy("Abort");
 226
 227         doReturn(rainyDayHandlerStatus).when(MOCK_catalogDbClient).getRainyDayHandlerStatus("AssignServiceInstanceBB",
 228                 "st1", "vnft1", "7000", "*", "errorMessage", "*");
 229
 230         executeBuildingBlockRainyDay.queryRainyDayTable(delegateExecution, true);
 231
 232         assertEquals("RollbackToAssigned", delegateExecution.getVariable("handlingCode"));
 233         assertEquals(Status.ROLLED_BACK_TO_ASSIGNED.toString(), delegateExecution.getVariable("rollbackTargetState"));
 234     }
 235
 236     @Test
 237     public void queryRainyDayTableRollbackToCreated() throws Exception {
 238         customer.getServiceSubscription().getServiceInstances().add(serviceInstance);
 239         serviceInstance.getModelInfoServiceInstance().setServiceType("st1");
 240         vnf.setVnfType("vnft1");
 241         delegateExecution.setVariable("aLaCarte", true);
 242         delegateExecution.setVariable("suppressRollback", false);
 243         delegateExecution.setVariable("WorkflowExceptionCode", "7000");
 244         RainyDayHandlerStatus rainyDayHandlerStatus = new RainyDayHandlerStatus();
 245         rainyDayHandlerStatus.setErrorCode("7000");
 246         rainyDayHandlerStatus.setFlowName("AssignServiceInstanceBB");
 247         rainyDayHandlerStatus.setServiceType("st1");
 248         rainyDayHandlerStatus.setVnfType("vnft1");
 249         rainyDayHandlerStatus.setPolicy("RollbackToCreated");
 250         rainyDayHandlerStatus.setWorkStep(ASTERISK);
 251         rainyDayHandlerStatus.setSecondaryPolicy("Abort");
 252
 253         doReturn(rainyDayHandlerStatus).when(MOCK_catalogDbClient).getRainyDayHandlerStatus("AssignServiceInstanceBB",
 254                 "st1", "vnft1", "7000", "*", "errorMessage", "*");
 255
 256         executeBuildingBlockRainyDay.queryRainyDayTable(delegateExecution, true);
 257
 258         assertEquals("RollbackToCreated", delegateExecution.getVariable("handlingCode"));
 259         assertEquals(Status.ROLLED_BACK_TO_CREATED.toString(), delegateExecution.getVariable("rollbackTargetState"));
 260     }
 261
 262
 263     @Test
 264     public void suppressRollbackTest() throws Exception {
 265         delegateExecution.setVariable("suppressRollback", true);
 266         delegateExecution.setVariable("aLaCarte", true);
 267         executeBuildingBlockRainyDay.queryRainyDayTable(delegateExecution, true);
 268         assertEquals("Abort", delegateExecution.getVariable("handlingCode"));
 269     }
 270
 271     @Test
 272     public void queryRainyDayTableServiceRoleNotDefined() throws Exception {
 273         customer.getServiceSubscription().getServiceInstances().add(serviceInstance);
 274         serviceInstance.getModelInfoServiceInstance().setServiceType("st1");
 275         serviceInstance.getModelInfoServiceInstance().setServiceRole("sr1");
 276         vnf.setVnfType("vnft1");
 277         delegateExecution.setVariable("aLaCarte", true);
 278         delegateExecution.setVariable("suppressRollback", false);
 279         delegateExecution.setVariable("WorkflowExceptionCode", "7000");
 280         RainyDayHandlerStatus rainyDayHandlerStatus = new RainyDayHandlerStatus();
 281         rainyDayHandlerStatus.setErrorCode("7000");
 282         rainyDayHandlerStatus.setFlowName("AssignServiceInstanceBB");
 283         rainyDayHandlerStatus.setServiceType("st1");
 284         rainyDayHandlerStatus.setVnfType("vnft1");
 285         rainyDayHandlerStatus.setPolicy("Rollback");
 286         rainyDayHandlerStatus.setWorkStep(ASTERISK);
 287
 288         doReturn(rainyDayHandlerStatus).when(MOCK_catalogDbClient).getRainyDayHandlerStatus("AssignServiceInstanceBB",
 289                 "st1", "vnft1", "7000", "*", "errorMessage", "sr1");
 290
 291         executeBuildingBlockRainyDay.queryRainyDayTable(delegateExecution, true);
 292         assertEquals("Rollback", delegateExecution.getVariable("handlingCode"));
 293     }
 294
 295     @Test
 296     public void queryRainyDayTableServiceRoleNC() throws Exception {
 297         customer.getServiceSubscription().getServiceInstances().add(serviceInstance);
 298         serviceInstance.getModelInfoServiceInstance().setServiceType("st1");
 299         serviceInstance.getModelInfoServiceInstance().setServiceRole("NETWORK-COLLECTION");
 300         vnf.setVnfType("vnft1");
 301         delegateExecution.setVariable("aLaCarte", true);
 302         delegateExecution.setVariable("suppressRollback", false);
 303         delegateExecution.setVariable("WorkflowExceptionCode", "7000");
 304         RainyDayHandlerStatus rainyDayHandlerStatus = new RainyDayHandlerStatus();
 305         rainyDayHandlerStatus.setErrorCode("7000");
 306         rainyDayHandlerStatus.setFlowName("ActivateServiceInstanceBB");
 307         rainyDayHandlerStatus.setServiceType("st1");
 308         rainyDayHandlerStatus.setVnfType("vnft1");
 309         rainyDayHandlerStatus.setPolicy("Abort");
 310         rainyDayHandlerStatus.setWorkStep(ASTERISK);
 311
 312         doReturn(rainyDayHandlerStatus).when(MOCK_catalogDbClient).getRainyDayHandlerStatus("AssignServiceInstanceBB",
 313                 "st1", "vnft1", "7000", "*", "errorMessage", "NETWORK-COLLECTION");
 314
 315         executeBuildingBlockRainyDay.queryRainyDayTable(delegateExecution, true);
 316         assertEquals("Abort", delegateExecution.getVariable("handlingCode"));
 317     }
 318
 319 }