vnfapi/provider/src/test/java/org/onap/sdnc/vnfapi/VnfInstanceTopologyOperationTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * openECOMP : SDN-C
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights
   6  *                                                      reserved.
   7  * ================================================================================
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  * ============LICENSE_END=========================================================
  20  */
  21
  22 package org.onap.sdnc.vnfapi;
  23
  24 import com.google.common.util.concurrent.CheckedFuture;
  25 import org.junit.Assert;
  26 import org.junit.Before;
  27 import org.junit.Test;
  28 import org.junit.runner.RunWith;
  29 import org.mockito.runners.MockitoJUnitRunner;
  30 import org.mockito.Mockito;
  31 import org.onap.ccsdk.sli.core.sli.SvcLogicException;
  32 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  33 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  34 import org.opendaylight.controller.md.sal.binding.impl.BindingDOMDataBrokerAdapter;
  35 import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec;
  36 import org.opendaylight.controller.md.sal.binding.test.AbstractDataBrokerTestCustomizer;
  37 import org.opendaylight.controller.md.sal.binding.test.ConcurrentDataBrokerTestCustomizer;
  38 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  39 import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
  40 import org.slf4j.Logger;
  41 import org.slf4j.LoggerFactory;
  42 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstanceTopologyOperationInput;
  43 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstanceTopologyOperationOutput;
  44 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.request.information.RequestInformation;
  45 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.request.information.RequestInformation.RequestAction;
  46 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.request.information.RequestInformationBuilder;
  47 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstanceTopologyOperationInputBuilder;
  48 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.request.information.VnfInstanceRequestInformation;
  49 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.request.information.VnfInstanceRequestInformationBuilder;
  50 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.service.data.VnfInstanceServiceDataBuilder;
  51
  52 import java.util.Properties;
  53 import java.util.concurrent.ExecutionException;
  54
  55 class VnfInstanceExceptionThrowerConfigurator {
  56     private boolean shouldThrowExceptionDuringTransactionPut;
  57
  58     public VnfInstanceExceptionThrowerConfigurator() {
  59         this.shouldThrowExceptionDuringTransactionPut = true;
  60     }
  61
  62     public boolean shouldThrowExceptionDuringTransactionPut() {
  63         return shouldThrowExceptionDuringTransactionPut;
  64     }
  65
  66     public void setShouldThrowExceptionDuringTransactionPut(boolean shouldThrowExceptionDuringTransactionPut) {
  67         this.shouldThrowExceptionDuringTransactionPut = shouldThrowExceptionDuringTransactionPut;
  68     }
  69 }
  70
  71 class VnfInstanceDataBrokerErrorMsgConfigurator {
  72     static public String JAVA_LANG_RUNTIME_EXCEPTION = "java.lang.RuntimeException: ";
  73     static public String TRANSACTION_WRITE_ERROR = "transaction-write-error";
  74 }
  75
  76 class VnfInstanceDataBrokerStab extends BindingDOMDataBrokerAdapter {
  77     VnfInstanceExceptionThrowerConfigurator exceptionThrowerConfigurator;
  78
  79     public VnfInstanceDataBrokerStab(final DOMDataBroker domDataBroker,
  80         final BindingToNormalizedNodeCodec codec, VnfInstanceExceptionThrowerConfigurator exceptionThrowerConfigurator) {
  81         super(domDataBroker, codec);
  82         this.exceptionThrowerConfigurator = exceptionThrowerConfigurator;
  83
  84     }
  85
  86     @Override
  87     public WriteTransaction newWriteOnlyTransaction() {
  88         if (exceptionThrowerConfigurator.shouldThrowExceptionDuringTransactionPut()) {
  89             return newThrowingExceptionWriteOnlyTransaction();
  90         }
  91         return newNotThrowingExceptionWriteOnlyTransaction();
  92     }
  93
  94     private WriteTransaction newThrowingExceptionWriteOnlyTransaction() {
  95         WriteTransaction mockWriteTransaction = Mockito.mock(WriteTransaction.class);
  96         Mockito.doThrow(new RuntimeException(VnfInstanceDataBrokerErrorMsgConfigurator.TRANSACTION_WRITE_ERROR))
  97                 .when(mockWriteTransaction).put(Mockito.any(), Mockito.any(), Mockito.any());
  98         return mockWriteTransaction;
  99     }
 100
 101     private WriteTransaction newNotThrowingExceptionWriteOnlyTransaction() {
 102          WriteTransaction mockWriteTransaction = Mockito.mock(WriteTransaction.class);
 103         CheckedFuture<Void, TransactionCommitFailedException> mockCheckedFuture =
 104                 Mockito.mock(CheckedFuture.class);
 105         Mockito.doNothing().when(mockWriteTransaction).put(Mockito.any(), Mockito.any(), Mockito.any());
 106         Mockito.doReturn(mockCheckedFuture).when(mockWriteTransaction).submit();
 107         return mockWriteTransaction;
 108     }
 109 }
 110
 111 class VnfInstanceProviderDataBrokerTestCustomizer  extends ConcurrentDataBrokerTestCustomizer {
 112     VnfInstanceExceptionThrowerConfigurator exceptionThrowerConfigurator;
 113
 114     public VnfInstanceProviderDataBrokerTestCustomizer(VnfInstanceExceptionThrowerConfigurator exceptionThrowerConfigurator) {
 115         super(false);
 116         this.exceptionThrowerConfigurator = exceptionThrowerConfigurator;
 117     }
 118
 119     public DataBroker createDataBroker() {
 120         return new VnfInstanceDataBrokerStab(createDOMDataBroker(),
 121             super.getBindingToNormalized(), this.exceptionThrowerConfigurator);
 122     }
 123 }
 124
 125 @RunWith(MockitoJUnitRunner.class)
 126 public class VnfInstanceTopologyOperationTest extends VnfApiProviderTest {
 127     protected static final Logger LOG = LoggerFactory.getLogger(VnfInstanceTopologyOperationTest.class);
 128
 129     private static final String INVALID_INPUT = "invalid input, null or empty vnf-instance-id";
 130     private static final String NO_SERVICE_LOGIC = "No service logic active for VNF-API: \'vnf-instance-topology-operation\'";
 131     private static final String VIID = "viid";
 132     private static final String PRELOAD_NAME = "preloadName";
 133     private static final String PRELOAD_TYPE = "preloadType";
 134     private static final String ERROR_CODE = "error-code";
 135     private static final String ERROR_MESSAGE = "error-message";
 136     private static final String ACK_FINAL = "ack-final";
 137     private static final String SVC_OPERATION = "vnf-topology-operation";
 138
 139     private VnfInstanceExceptionThrowerConfigurator exceptionThrowerConfigurator;
 140
 141     @Override
 142     protected AbstractDataBrokerTestCustomizer createDataBrokerTestCustomizer() {
 143         this.exceptionThrowerConfigurator = new VnfInstanceExceptionThrowerConfigurator();
 144         return new VnfInstanceProviderDataBrokerTestCustomizer(this.exceptionThrowerConfigurator);
 145     }
 146
 147     @Before
 148     public void setUp() throws Exception {
 149         super.setUp();
 150         svcClient.setScvOperation(SVC_OPERATION);
 151     }
 152
 153     @Test
 154     public void vnfInstanceTopologyOperationInputIsNull() throws Exception {
 155         VnfInstanceTopologyOperationInput input = null;
 156         checkVnfInstanceTopologyOperation(input, "403", INVALID_INPUT);
 157     }
 158
 159     @Test
 160     public void vnfInstanceTopologyOperationInput_VnfInstanceRequestInformationIsNull() throws Exception {
 161         VnfInstanceTopologyOperationInputBuilder builder = new VnfInstanceTopologyOperationInputBuilder();
 162         builder.setVnfInstanceRequestInformation(null);
 163         VnfInstanceTopologyOperationInput input = builder.build();
 164         checkVnfInstanceTopologyOperation(input, "403", INVALID_INPUT);
 165     }
 166
 167     @Test
 168     public void vnfInstanceTopologyOperationInput_getVnfInstanceRequestInformationVnfInstanceIdIsNull() throws Exception {
 169         RequestInformation reqInfo = createRequestInformation(RequestAction.PreloadVnfInstanceRequest);
 170         VnfInstanceRequestInformation vnfInstanceRequestInformation = createVnfInstanceRequestInformation(null);
 171         VnfInstanceTopologyOperationInputBuilder builder = createVnfInstanceTopologyOperationInputBuilder(vnfInstanceRequestInformation, reqInfo);
 172         VnfInstanceTopologyOperationInput input = builder.build();
 173         checkVnfInstanceTopologyOperation(input, "403", INVALID_INPUT);
 174     }
 175
 176     @Test
 177     public void vnfInstanceTopologyOperationInput_VnfInstanceRequestInformationVnfInstanceIdIsZero() throws Exception {
 178         VnfInstanceTopologyOperationInputBuilder builder = createVnfInstanceTopologyOperationInputBuilder(createVnfInstanceRequestInformation(""), createRequestInformation(RequestAction.PreloadVnfInstanceRequest));
 179         VnfInstanceTopologyOperationInput input = builder.build();
 180         checkVnfInstanceTopologyOperation(input, "403", INVALID_INPUT);
 181     }
 182
 183     @Test
 184     public void vnfInstanceTopologyOperationInput_svcLogicClientHasGrapheReturnFalse() throws Exception {
 185         VnfInstanceTopologyOperationInputBuilder builder = createVnfInstanceTopologyOperationInputBuilder(createVnfInstanceRequestInformation(VIID), createRequestInformation(RequestAction.PreloadVnfInstanceRequest));
 186         VnfInstanceTopologyOperationInput input = builder.build();
 187         setReturnForSvcLogicServiceClientHasGraph(false);
 188         checkVnfInstanceTopologyOperation(input, "503", NO_SERVICE_LOGIC);
 189     }
 190
 191     @Test
 192     public void vnfInstanceTopologyOperationInput_svcLogicClientExecuteThrowsSvcLogicException() throws Exception {
 193         VnfInstanceTopologyOperationInputBuilder builder = createVnfInstanceTopologyOperationInputBuilder(createVnfInstanceRequestInformation(VIID), createRequestInformation(RequestAction.PreloadVnfInstanceRequest));
 194         VnfInstanceTopologyOperationInput input = builder.build();
 195         setReturnForSvcLogicServiceClientHasGraph(true);
 196         setMockVNFSDNSvcLogicServiceClientToThrowException(SvcLogicException.class);
 197         checkVnfInstanceTopologyOperation(input, "500", null);
 198     }
 199
 200     @Test
 201     public void vnfInstanceTopologyOperationInput_svcLogicClientExecuteThrowsException() throws Exception {
 202         VnfInstanceTopologyOperationInputBuilder builder = createVnfInstanceTopologyOperationInputBuilder(createVnfInstanceRequestInformation(VIID), createRequestInformation(RequestAction.PreloadVnfInstanceRequest));
 203         VnfInstanceTopologyOperationInput input = builder.build();
 204
 205         setReturnForSvcLogicServiceClientHasGraph(true);
 206         setMockVNFSDNSvcLogicServiceClientToThrowException(Exception.class);
 207         checkVnfInstanceTopologyOperation(input, "500", null);
 208     }
 209
 210     @Test
 211     public void vnfInstanceTopologyOperationInput_svcLogicClientExecuteReturnsNotNull() throws Exception {
 212         VnfInstanceTopologyOperationInputBuilder builder = createVnfInstanceTopologyOperationInputBuilder(createVnfInstanceRequestInformation(VIID), createRequestInformation(RequestAction.PreloadVnfInstanceRequest));
 213         VnfInstanceTopologyOperationInput input = builder.build();
 214
 215         Properties properties = prop().set(ERROR_CODE, "500")
 216                 .set(ERROR_MESSAGE, ERROR_MESSAGE)
 217                 .set(ACK_FINAL, "Y")
 218                 .build();
 219
 220         setReturnForSvcLogicServiceClientHasGraph(true);
 221         setReturnForSvcLogicServiceClientExecute(properties);
 222         checkVnfInstanceTopologyOperation(input, "500", ERROR_MESSAGE);
 223     }
 224
 225     @Test
 226     public void vnfInstanceTopologyOperationInput_svcLogicClientExecuteReturnsNull() throws Exception {
 227         VnfInstanceTopologyOperationInputBuilder builder = createVnfInstanceTopologyOperationInputBuilder(createVnfInstanceRequestInformation(VIID), createRequestInformation(RequestAction.PreloadVnfInstanceRequest));
 228         VnfInstanceTopologyOperationInput input = builder.build();
 229
 230         setReturnForSvcLogicServiceClientHasGraph(true);
 231         setReturnForSvcLogicServiceClientExecute(null);
 232         String expectedErrorMsg = VnfInstanceDataBrokerErrorMsgConfigurator.JAVA_LANG_RUNTIME_EXCEPTION
 233                 + VnfInstanceDataBrokerErrorMsgConfigurator.TRANSACTION_WRITE_ERROR;
 234         checkVnfInstanceTopologyOperation(input, "500", expectedErrorMsg);
 235     }
 236
 237     @Test
 238     public void vnfInstanceTopologyOperationInput_ActivateNoErrorDuringTransactionWriting() throws Exception {
 239         VnfInstanceTopologyOperationInputBuilder builder = createVnfInstanceTopologyOperationInputBuilder(createVnfInstanceRequestInformation(VIID), createRequestInformation(RequestAction.VnfInstanceActivateRequest));
 240         VnfInstanceTopologyOperationInput input = builder.build();
 241
 242         setReturnForSvcLogicServiceClientHasGraph(true);
 243         setReturnForSvcLogicServiceClientExecute(null);
 244         exceptionThrowerConfigurator.setShouldThrowExceptionDuringTransactionPut(false);
 245         checkVnfInstanceTopologyOperation(input, "200", null);
 246     }
 247
 248     @Test
 249     public void vnfInstanceTopologyOperationInput_ChangeNoErrorDuringTransactionWriting() throws Exception {
 250         VnfInstanceTopologyOperationInputBuilder builder = createVnfInstanceTopologyOperationInputBuilder(createVnfInstanceRequestInformation(VIID), createRequestInformation(RequestAction.ChangeVnfInstanceActivateRequest));
 251         VnfInstanceTopologyOperationInput input = builder.build();
 252
 253         setReturnForSvcLogicServiceClientHasGraph(true);
 254         setReturnForSvcLogicServiceClientExecute(null);
 255         exceptionThrowerConfigurator.setShouldThrowExceptionDuringTransactionPut(false);
 256         checkVnfInstanceTopologyOperation(input, "200", null);
 257     }
 258
 259     @Test
 260     public void vnfInstanceTopologyOperationInput_DisconnectNoErrorDuringTransactionWriting() throws Exception {
 261         VnfInstanceTopologyOperationInputBuilder builder = createVnfInstanceTopologyOperationInputBuilder(createVnfInstanceRequestInformation(VIID), createRequestInformation(RequestAction.DisconnectVnfInstanceRequest));
 262         VnfInstanceTopologyOperationInput input = builder.build();
 263
 264         setReturnForSvcLogicServiceClientHasGraph(true);
 265         setReturnForSvcLogicServiceClientExecute(null);
 266         exceptionThrowerConfigurator.setShouldThrowExceptionDuringTransactionPut(false);
 267         checkVnfInstanceTopologyOperation(input, "200", null);
 268     }
 269
 270     @Test
 271     public void vnfInstanceTopologyOperationInput_PreloadNoErrorDuringTransactionWriting() throws Exception {
 272         VnfInstanceTopologyOperationInputBuilder builder = createVnfInstanceTopologyOperationInputBuilder(createVnfInstanceRequestInformation(VIID), createRequestInformation(RequestAction.PreloadVnfInstanceRequest));
 273         VnfInstanceTopologyOperationInput input = builder.build();
 274
 275         setReturnForSvcLogicServiceClientHasGraph(true);
 276         setReturnForSvcLogicServiceClientExecute(null);
 277         exceptionThrowerConfigurator.setShouldThrowExceptionDuringTransactionPut(false);
 278         checkVnfInstanceTopologyOperation(input, "200", null);
 279     }
 280
 281     @Test
 282     public void vnfInstanceTopologyOperationInput_DeletePreloadNoErrorDuringTransactionWriting() throws Exception {
 283         VnfInstanceTopologyOperationInputBuilder builder = createVnfInstanceTopologyOperationInputBuilder(createVnfInstanceRequestInformation(VIID), createRequestInformation(RequestAction.DeletePreloadVnfInstanceRequest));
 284         VnfInstanceTopologyOperationInput input = builder.build();
 285
 286         setReturnForSvcLogicServiceClientHasGraph(true);
 287         setReturnForSvcLogicServiceClientExecute(null);
 288         exceptionThrowerConfigurator.setShouldThrowExceptionDuringTransactionPut(false);
 289         checkVnfInstanceTopologyOperation(input, "200", null);
 290     }
 291     private void checkVnfInstanceTopologyOperation(VnfInstanceTopologyOperationInput input,
 292         String expectedResponseCode, String expectedResponseMessage) throws ExecutionException, InterruptedException {
 293
 294         VnfInstanceTopologyOperationOutput output = executeVnfInstanceTopologyOperation(input);
 295         checkVnfInstanceTopologyOperationOutput(output, expectedResponseCode, expectedResponseMessage);
 296     }
 297
 298     private VnfInstanceTopologyOperationOutput executeVnfInstanceTopologyOperation(
 299         VnfInstanceTopologyOperationInput input) throws ExecutionException, InterruptedException {
 300         return vnfapiProvider
 301                 .vnfInstanceTopologyOperation(input)
 302                 .get()
 303                 .getResult();
 304     }
 305
 306     private void checkVnfInstanceTopologyOperationOutput(VnfInstanceTopologyOperationOutput result,
 307         String expectedResponseCode, String expectedResponseMessage) {
 308
 309         String expectedAckFinalIndicator = "Y";
 310
 311         Assert.assertEquals(expectedResponseCode , result.getResponseCode());
 312         Assert.assertEquals(expectedResponseMessage, result.getResponseMessage());
 313         Assert.assertEquals(expectedAckFinalIndicator, result.getAckFinalIndicator());
 314     }
 315
 316     private void setReturnForSvcLogicServiceClientHasGraph(Boolean returnValue) throws Exception{
 317         Mockito.when(mockVNFSDNSvcLogicServiceClient
 318                 .hasGraph(Mockito.any(),Mockito.any(), Mockito.any(),Mockito.any()))
 319                 .thenReturn(returnValue);
 320     }
 321
 322     private void setReturnForSvcLogicServiceClientExecute(Properties properties) throws Exception{
 323         Mockito.when(mockVNFSDNSvcLogicServiceClient
 324                 .execute(Mockito.any(),
 325                         Mockito.any(),
 326                         Mockito.any(),
 327                         Mockito.any(),
 328                         Mockito.any(VnfInstanceServiceDataBuilder.class),
 329                         Mockito.any()))
 330                 .thenReturn(properties);
 331     }
 332
 333     private void setMockVNFSDNSvcLogicServiceClientToThrowException(Class exceptionClass) throws Exception {
 334         Mockito.when(mockVNFSDNSvcLogicServiceClient
 335                 .execute(Mockito.any(),
 336                         Mockito.any(),
 337                         Mockito.any(),
 338                         Mockito.any(),
 339                         Mockito.any(VnfInstanceServiceDataBuilder.class),
 340                         Mockito.any()))
 341                 .thenThrow(exceptionClass.asSubclass(Throwable.class));
 342     }
 343
 344     private VnfInstanceTopologyOperationInputBuilder createVnfInstanceTopologyOperationInputBuilder(VnfInstanceRequestInformation vnfInstanceRequestInformation, RequestInformation reqInfo) {
 345         VnfInstanceTopologyOperationInputBuilder builder = new VnfInstanceTopologyOperationInputBuilder();
 346         builder.setVnfInstanceRequestInformation(vnfInstanceRequestInformation);
 347         builder.setRequestInformation(reqInfo);
 348         return builder;
 349     }
 350
 351
 352
 353     private VnfInstanceRequestInformation createVnfInstanceRequestInformation(String vnfInstanceId) {
 354         return new VnfInstanceRequestInformationBuilder()
 355                 .setVnfInstanceId(vnfInstanceId)
 356                 .setVnfInstanceName(PRELOAD_NAME)
 357                 .setVnfModelId(PRELOAD_TYPE)
 358                 .build();
 359     }
 360
 361     private RequestInformation createRequestInformation(RequestAction action) {
 362         return new RequestInformationBuilder()
 363                 .setRequestAction(action)
 364                 .build();
 365     }
 366
 367
 368 }