appc-provider/appc-provider-bundle/src/test/java/org/openecomp/appc/provider/AppcProviderLcmTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP : APPC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Copyright (C) 2017 Amdocs
   8  * =============================================================================
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  * ECOMP is a trademark and service mark of AT&T Intellectual Property.
  22  * ============LICENSE_END=========================================================
  23  */
  24
  25 package org.onap.appc.provider;
  26
  27 import org.junit.After;
  28 import org.junit.Assert;
  29 import org.junit.Before;
  30 import org.junit.Test;
  31 import org.junit.runner.RunWith;
  32 import org.mockito.Mock;
  33 import org.mockito.Spy;
  34 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  35 import org.opendaylight.controller.md.sal.binding.test.AbstractDataBrokerTest;
  36 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
  37 import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
  38 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
  39 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AuditInput;
  40 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AuditOutput;
  41 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.CheckLockInput;
  42 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.CheckLockOutput;
  43 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigBackupDeleteInput;
  44 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigBackupDeleteOutput;
  45 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigBackupInput;
  46 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigBackupOutput;
  47 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigExportInput;
  48 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigExportOutput;
  49 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigModifyInput;
  50 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigModifyOutput;
  51 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigRestoreInput;
  52 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigRestoreOutput;
  53 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigScaleoutInput;
  54 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigScaleoutOutput;
  55 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigureInput;
  56 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigureOutput;
  57 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.EvacuateInput;
  58 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.EvacuateOutput;
  59 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.HealthCheckInput;
  60 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.HealthCheckOutput;
  61 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.LiveUpgradeInput;
  62 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.LiveUpgradeOutput;
  63 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.LockInput;
  64 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.LockOutput;
  65 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.MigrateInput;
  66 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.MigrateOutput;
  67 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RebuildInput;
  68 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RebuildOutput;
  69 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RestartInput;
  70 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RestartOutput;
  71 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RollbackInput;
  72 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RollbackOutput;
  73 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SnapshotInput;
  74 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SnapshotOutput;
  75 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SoftwareUploadInput;
  76 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SoftwareUploadOutput;
  77 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StartApplicationInput;
  78 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StartApplicationOutput;
  79 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StartInput;
  80 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StartOutput;
  81 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StopApplicationInput;
  82 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StopApplicationOutput;
  83 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StopInput;
  84 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StopOutput;
  85 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SyncInput;
  86 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SyncOutput;
  87 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.TerminateInput;
  88 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.TerminateOutput;
  89 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.TestInput;
  90 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.TestOutput;
  91 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UnlockInput;
  92 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UnlockOutput;
  93 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ZULU;
  94 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.action.identifiers.ActionIdentifiers;
  95 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.action.identifiers.ActionIdentifiersBuilder;
  96 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.common.header.CommonHeader;
  97 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.common.header.CommonHeaderBuilder;
  98 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.status.Status;
  99 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.status.StatusBuilder;
 100 import org.opendaylight.yangtools.yang.common.RpcResult;
 101 import org.onap.appc.domainmodel.lcm.ResponseContext;
 102 import org.onap.appc.executor.objects.LCMCommandStatus;
 103 import org.onap.appc.provider.lcm.util.ValidationService;
 104 import org.onap.appc.requesthandler.objects.RequestHandlerOutput;
 105 import org.osgi.framework.FrameworkUtil;
 106 import org.powermock.api.mockito.PowerMockito;
 107 import org.powermock.core.classloader.annotations.PrepareForTest;
 108 import org.powermock.modules.junit4.PowerMockRunner;
 109 import org.powermock.reflect.Whitebox;
 110
 111 import java.time.Clock;
 112 import java.time.LocalDateTime;
 113 import java.util.HashMap;
 114 import java.util.Map;
 115 import java.util.concurrent.ExecutorService;
 116 import java.util.concurrent.Executors;
 117 import java.util.concurrent.Future;
 118
 119 import static org.mockito.Matchers.any;
 120 import static org.mockito.Mockito.doReturn;
 121 import static org.mockito.Mockito.mock;
 122 import static org.mockito.Mockito.spy;
 123 import static org.mockito.Mockito.times;
 124 import static org.mockito.Mockito.verify;
 125 import static org.powermock.api.mockito.PowerMockito.mockStatic;
 126
 127 /**
 128  * Integration Test class for AppcProviderLcm.
 129  */
 130 @RunWith(PowerMockRunner.class)
 131 @PrepareForTest({FrameworkUtil.class, AppcProviderLcm.class, ValidationService.class})
 132 public class AppcProviderLcmTest extends AbstractDataBrokerTest {
 133     private Status successStatus = new StatusBuilder().setCode(400).setMessage("success").build();
 134     private Status failStatus = new StatusBuilder().setCode(401).setMessage("failure").build();
 135
 136     private AppcProviderLcm appcProviderLcm;
 137     private DataBroker dataBroker;
 138     @Spy
 139     private ValidationService validationService = ValidationService.getInstance();
 140     @Mock
 141     private RequestHandlerOutput requestHandlerOutput;
 142     @Mock
 143     private ResponseContext responseContext;
 144     @Mock
 145     private org.onap.appc.domainmodel.lcm.Status successlcmStatus;
 146
 147     /**
 148      * The @Before annotation is defined in the AbstractDataBrokerTest class. The method setupWithDataBroker is invoked
 149      * from inside the @Before method and is used to initialize the databroker with objects for a test runs. In our case
 150      * we use this oportunity to create an instance of our provider and initialize it (which registers it as a listener
 151      * etc). This method runs before every @Test method below.
 152      */
 153     @Override
 154     protected void setupWithDataBroker(DataBroker dataBroker) {
 155         super.setupWithDataBroker(dataBroker);
 156
 157         this.dataBroker = dataBroker;
 158     }
 159
 160     @Before
 161     public void setUp() throws Exception {
 162         //mock appcProviderLcm
 163         NotificationProviderService nps = mock(NotificationProviderService.class);
 164         RpcProviderRegistry registry = mock(RpcProviderRegistry.class);
 165         BindingAwareBroker.RpcRegistration rpcRegistration = mock(BindingAwareBroker.RpcRegistration.class);
 166         PowerMockito.doReturn(rpcRegistration).when(registry).addRpcImplementation(any(), any());
 167         appcProviderLcm = spy(new AppcProviderLcm(dataBroker, nps, registry));
 168         //mock validationService
 169         mockStatic(ValidationService.class);
 170         PowerMockito.when(ValidationService.getInstance()).thenReturn(validationService);
 171
 172         doReturn(successlcmStatus).when(responseContext).getStatus();
 173         doReturn(400).when(successlcmStatus).getCode();
 174         doReturn("success").when(successlcmStatus).getMessage();
 175     }
 176
 177     @Test
 178     public void testConstructor() throws Exception {
 179         ExecutorService executorService = Whitebox.getInternalState(appcProviderLcm, "executor");
 180         Assert.assertNotNull(executorService);
 181         BindingAwareBroker.RpcRegistration internalRpcRegistration = Whitebox.getInternalState(appcProviderLcm,
 182             "rpcRegistration");
 183         Assert.assertNotNull(internalRpcRegistration);
 184     }
 185
 186     @Test
 187     public void testClose() throws Exception {
 188         ExecutorService executorService = spy(Executors.newFixedThreadPool(1));
 189         Whitebox.setInternalState(appcProviderLcm, "executor", executorService);
 190         BindingAwareBroker.RpcRegistration rpcRegistration = mock(BindingAwareBroker.RpcRegistration.class);
 191         Whitebox.setInternalState(appcProviderLcm, "rpcRegistration", rpcRegistration);
 192         appcProviderLcm.close();
 193
 194         verify(executorService, times(1)).shutdown();
 195         verify(rpcRegistration, times(1)).close();
 196     }
 197
 198     @Test
 199     public void testRebuild() throws Exception {
 200         // Validation success
 201         doReturn("Success").when(successlcmStatus).getMessage();
 202         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 203         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 204         doReturn(null).when(validationService).validateInput(any(), any(), any());
 205
 206         RebuildInput rebuildInput = mock(RebuildInput.class);
 207         doReturn(newCommonHeader("request-id-test")).when(rebuildInput).getCommonHeader();
 208         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 209             .when(rebuildInput).getActionIdentifiers();
 210
 211         Future<RpcResult<RebuildOutput>> results = appcProviderLcm.rebuild(rebuildInput);
 212         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 213         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 214         verify(appcProviderLcm, times(1)).executeRequest(any());
 215
 216         // Validation failed
 217         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 218         results = appcProviderLcm.rebuild(rebuildInput);
 219         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 220         verify(appcProviderLcm, times(1)).executeRequest(any());
 221
 222         // parse exception
 223         doReturn(null).when(validationService).validateInput(any(), any(), any());
 224         doReturn(null).when(rebuildInput).getActionIdentifiers();
 225         results = appcProviderLcm.rebuild(rebuildInput);
 226         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 227             == results.get().getResult().getStatus().getCode());
 228         verify(appcProviderLcm, times(1)).executeRequest(any());
 229     }
 230
 231     @Test
 232     public void testRestart() throws Exception {
 233         // Validation success
 234         doReturn("Success").when(successlcmStatus).getMessage();
 235         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 236         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 237         doReturn(null).when(validationService).validateInput(any(), any(), any());
 238
 239         RestartInput restartInput = mock(RestartInput.class);
 240         doReturn(newCommonHeader("request-id-test")).when(restartInput).getCommonHeader();
 241         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 242             .when(restartInput).getActionIdentifiers();
 243
 244         Future<RpcResult<RestartOutput>> results = appcProviderLcm.restart(restartInput);
 245         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 246         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 247         verify(appcProviderLcm, times(1)).executeRequest(any());
 248
 249         // Validation failed
 250         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 251         results = appcProviderLcm.restart(restartInput);
 252         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 253         verify(appcProviderLcm, times(1)).executeRequest(any());
 254
 255         // parse exception
 256         doReturn(null).when(validationService).validateInput(any(), any(), any());
 257         doReturn(null).when(restartInput).getActionIdentifiers();
 258         results = appcProviderLcm.restart(restartInput);
 259         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 260             == results.get().getResult().getStatus().getCode());
 261         verify(appcProviderLcm, times(1)).executeRequest(any());
 262     }
 263
 264     @Test
 265     public void testStartApplication() throws Exception {
 266         // Validation success
 267         doReturn("Success").when(successlcmStatus).getMessage();
 268         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 269         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 270         doReturn(null).when(validationService).validateInput(any(), any(), any());
 271
 272         StartApplicationInput startApplicationInput = mock(StartApplicationInput.class);
 273         doReturn(newCommonHeader("request-id-test")).when(startApplicationInput).getCommonHeader();
 274         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 275             .when(startApplicationInput).getActionIdentifiers();
 276
 277         Future<RpcResult<StartApplicationOutput>> results = appcProviderLcm.startApplication(startApplicationInput);
 278         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 279         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 280         verify(appcProviderLcm, times(1)).executeRequest(any());
 281
 282         // Validation failed
 283         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 284         results = appcProviderLcm.startApplication(startApplicationInput);
 285         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 286         verify(appcProviderLcm, times(1)).executeRequest(any());
 287
 288         // parse exception
 289         doReturn(null).when(validationService).validateInput(any(), any(), any());
 290         doReturn(null).when(startApplicationInput).getActionIdentifiers();
 291         results = appcProviderLcm.startApplication(startApplicationInput);
 292         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 293             == results.get().getResult().getStatus().getCode());
 294         verify(appcProviderLcm, times(1)).executeRequest(any());
 295     }
 296
 297     @Test
 298     public void testMigrate() throws Exception {
 299         // Validation success
 300         doReturn("Success").when(successlcmStatus).getMessage();
 301         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 302         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 303         doReturn(null).when(validationService).validateInput(any(), any(), any());
 304
 305         MigrateInput migrateInput = mock(MigrateInput.class);
 306         doReturn(newCommonHeader("request-id-test")).when(migrateInput).getCommonHeader();
 307         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 308             .when(migrateInput).getActionIdentifiers();
 309
 310         Future<RpcResult<MigrateOutput>> results = appcProviderLcm.migrate(migrateInput);
 311         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 312         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 313         verify(appcProviderLcm, times(1)).executeRequest(any());
 314
 315         // Validation failed
 316         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 317         results = appcProviderLcm.migrate(migrateInput);
 318         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 319         verify(appcProviderLcm, times(1)).executeRequest(any());
 320
 321         // parse exception
 322         doReturn(null).when(validationService).validateInput(any(), any(), any());
 323         doReturn(null).when(migrateInput).getActionIdentifiers();
 324         results = appcProviderLcm.migrate(migrateInput);
 325         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 326             == results.get().getResult().getStatus().getCode());
 327         verify(appcProviderLcm, times(1)).executeRequest(any());
 328     }
 329
 330     @Test
 331     public void testEvacuate() throws Exception {
 332         // Validation success
 333         doReturn("Success").when(successlcmStatus).getMessage();
 334         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 335         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 336         doReturn(null).when(validationService).validateInput(any(), any(), any());
 337
 338         EvacuateInput evacuateInput = mock(EvacuateInput.class);
 339         doReturn(newCommonHeader("request-id-test")).when(evacuateInput).getCommonHeader();
 340         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 341             .when(evacuateInput).getActionIdentifiers();
 342
 343         Future<RpcResult<EvacuateOutput>> results = appcProviderLcm.evacuate(evacuateInput);
 344         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 345         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 346         verify(appcProviderLcm, times(1)).executeRequest(any());
 347
 348         // Validation failed
 349         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 350         results = appcProviderLcm.evacuate(evacuateInput);
 351         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 352         verify(appcProviderLcm, times(1)).executeRequest(any());
 353
 354         // parse exception
 355         doReturn(null).when(validationService).validateInput(any(), any(), any());
 356         doReturn(null).when(evacuateInput).getActionIdentifiers();
 357         results = appcProviderLcm.evacuate(evacuateInput);
 358         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 359             == results.get().getResult().getStatus().getCode());
 360         verify(appcProviderLcm, times(1)).executeRequest(any());
 361     }
 362
 363     @Test
 364     public void testSnapshot() throws Exception {
 365         // Validation success
 366         doReturn("Success").when(successlcmStatus).getMessage();
 367         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 368         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 369         doReturn(null).when(validationService).validateInput(any(), any(), any());
 370
 371         SnapshotInput snapshotInput = mock(SnapshotInput.class);
 372         doReturn(newCommonHeader("request-id-test")).when(snapshotInput).getCommonHeader();
 373         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 374             .when(snapshotInput).getActionIdentifiers();
 375
 376         Future<RpcResult<SnapshotOutput>> results = appcProviderLcm.snapshot(snapshotInput);
 377         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 378         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 379         verify(appcProviderLcm, times(1)).executeRequest(any());
 380
 381         // Validation failed
 382         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 383         results = appcProviderLcm.snapshot(snapshotInput);
 384         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 385         verify(appcProviderLcm, times(1)).executeRequest(any());
 386
 387         // parse exception
 388         doReturn(null).when(validationService).validateInput(any(), any(), any());
 389         doReturn(null).when(snapshotInput).getActionIdentifiers();
 390         results = appcProviderLcm.snapshot(snapshotInput);
 391         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 392             == results.get().getResult().getStatus().getCode());
 393         verify(appcProviderLcm, times(1)).executeRequest(any());
 394     }
 395
 396     @Test
 397     public void testRollback() throws Exception {
 398         // Validation success
 399         doReturn("Success").when(successlcmStatus).getMessage();
 400         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 401         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 402         doReturn(null).when(validationService).validateInput(any(), any(), any());
 403
 404         RollbackInput rollbackInput = mock(RollbackInput.class);
 405         doReturn(newCommonHeader("request-id-test")).when(rollbackInput).getCommonHeader();
 406         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 407             .when(rollbackInput).getActionIdentifiers();
 408
 409         Future<RpcResult<RollbackOutput>> results = appcProviderLcm.rollback(rollbackInput);
 410         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 411         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 412         verify(appcProviderLcm, times(1)).executeRequest(any());
 413
 414         // Validation failed
 415         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 416         results = appcProviderLcm.rollback(rollbackInput);
 417         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 418         verify(appcProviderLcm, times(1)).executeRequest(any());
 419
 420         // parse exception
 421         doReturn(null).when(validationService).validateInput(any(), any(), any());
 422         doReturn(null).when(rollbackInput).getActionIdentifiers();
 423         results = appcProviderLcm.rollback(rollbackInput);
 424         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 425             == results.get().getResult().getStatus().getCode());
 426         verify(appcProviderLcm, times(1)).executeRequest(any());
 427     }
 428
 429     @Test
 430     public void testSync() throws Exception {
 431         // Validation success
 432         doReturn("Success").when(successlcmStatus).getMessage();
 433         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 434         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 435         doReturn(null).when(validationService).validateInput(any(), any(), any());
 436
 437         SyncInput syncInput = mock(SyncInput.class);
 438         doReturn(newCommonHeader("request-id-test")).when(syncInput).getCommonHeader();
 439         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 440             .when(syncInput).getActionIdentifiers();
 441
 442         Future<RpcResult<SyncOutput>> results = appcProviderLcm.sync(syncInput);
 443         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 444         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 445         verify(appcProviderLcm, times(1)).executeRequest(any());
 446
 447         // Validation failed
 448         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 449         results = appcProviderLcm.sync(syncInput);
 450         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 451         verify(appcProviderLcm, times(1)).executeRequest(any());
 452
 453         // parse exception
 454         doReturn(null).when(validationService).validateInput(any(), any(), any());
 455         doReturn(null).when(syncInput).getActionIdentifiers();
 456         results = appcProviderLcm.sync(syncInput);
 457         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 458             == results.get().getResult().getStatus().getCode());
 459         verify(appcProviderLcm, times(1)).executeRequest(any());
 460     }
 461
 462     @Test
 463     public void testTerminate() throws Exception {
 464         // Validation success
 465         doReturn("Success").when(successlcmStatus).getMessage();
 466         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 467         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 468         doReturn(null).when(validationService).validateInput(any(), any(), any());
 469
 470         TerminateInput terminateInput = mock(TerminateInput.class);
 471         doReturn(newCommonHeader("request-id-test")).when(terminateInput).getCommonHeader();
 472         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 473             .when(terminateInput).getActionIdentifiers();
 474
 475         Future<RpcResult<TerminateOutput>> results = appcProviderLcm.terminate(terminateInput);
 476         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 477         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 478         verify(appcProviderLcm, times(1)).executeRequest(any());
 479
 480         // Validation failed
 481         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 482         results = appcProviderLcm.terminate(terminateInput);
 483         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 484         verify(appcProviderLcm, times(1)).executeRequest(any());
 485
 486         // parse exception
 487         doReturn(null).when(validationService).validateInput(any(), any(), any());
 488         doReturn(null).when(terminateInput).getActionIdentifiers();
 489         results = appcProviderLcm.terminate(terminateInput);
 490         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 491             == results.get().getResult().getStatus().getCode());
 492         verify(appcProviderLcm, times(1)).executeRequest(any());
 493     }
 494
 495     @Test
 496     public void testConfigure() throws Exception {
 497         // Validation success
 498         doReturn("Success").when(successlcmStatus).getMessage();
 499         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 500         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 501         doReturn(null).when(validationService).validateInput(any(), any(), any());
 502
 503         ConfigureInput configureInput = mock(ConfigureInput.class);
 504         doReturn(newCommonHeader("request-id-test")).when(configureInput).getCommonHeader();
 505         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 506             .when(configureInput).getActionIdentifiers();
 507
 508         Future<RpcResult<ConfigureOutput>> results = appcProviderLcm.configure(configureInput);
 509         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 510         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 511         verify(appcProviderLcm, times(1)).executeRequest(any());
 512
 513         // Validation failed
 514         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 515         results = appcProviderLcm.configure(configureInput);
 516         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 517         verify(appcProviderLcm, times(1)).executeRequest(any());
 518
 519         // parse exception
 520         doReturn(null).when(validationService).validateInput(any(), any(), any());
 521         doReturn(null).when(configureInput).getActionIdentifiers();
 522         results = appcProviderLcm.configure(configureInput);
 523         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 524             == results.get().getResult().getStatus().getCode());
 525         verify(appcProviderLcm, times(1)).executeRequest(any());
 526     }
 527
 528     @Test
 529     public void testConfigModify() throws Exception {
 530         // Validation success
 531         doReturn("Success").when(successlcmStatus).getMessage();
 532         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 533         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 534         doReturn(null).when(validationService).validateInput(any(), any(), any());
 535
 536         ConfigModifyInput configModifyInput = mock(ConfigModifyInput.class);
 537         doReturn(newCommonHeader("request-id-test")).when(configModifyInput).getCommonHeader();
 538         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 539             .when(configModifyInput).getActionIdentifiers();
 540
 541         Future<RpcResult<ConfigModifyOutput>> results = appcProviderLcm.configModify(configModifyInput);
 542         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 543         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 544         verify(appcProviderLcm, times(1)).executeRequest(any());
 545
 546         // Validation failed
 547         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 548         results = appcProviderLcm.configModify(configModifyInput);
 549         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 550         verify(appcProviderLcm, times(1)).executeRequest(any());
 551
 552         // parse exception
 553         doReturn(null).when(validationService).validateInput(any(), any(), any());
 554         doReturn(null).when(configModifyInput).getActionIdentifiers();
 555         results = appcProviderLcm.configModify(configModifyInput);
 556         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 557             == results.get().getResult().getStatus().getCode());
 558         verify(appcProviderLcm, times(1)).executeRequest(any());
 559     }
 560
 561     @Test
 562     public void testConfigScaleout() throws Exception {
 563         // Validation success
 564         doReturn("Success").when(successlcmStatus).getMessage();
 565         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 566         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 567         doReturn(null).when(validationService).validateInput(any(), any(), any());
 568
 569         ConfigScaleoutInput configScaleoutInput = mock(ConfigScaleoutInput.class);
 570         doReturn(newCommonHeader("request-id-test")).when(configScaleoutInput).getCommonHeader();
 571         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 572             .when(configScaleoutInput).getActionIdentifiers();
 573
 574         Future<RpcResult<ConfigScaleoutOutput>> results = appcProviderLcm.configScaleout(configScaleoutInput);
 575         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 576         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 577         verify(appcProviderLcm, times(1)).executeRequest(any());
 578
 579         // Validation failed
 580         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 581         results = appcProviderLcm.configScaleout(configScaleoutInput);
 582         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 583         verify(appcProviderLcm, times(1)).executeRequest(any());
 584
 585         // parse exception
 586         doReturn(null).when(validationService).validateInput(any(), any(), any());
 587         doReturn(null).when(configScaleoutInput).getActionIdentifiers();
 588         results = appcProviderLcm.configScaleout(configScaleoutInput);
 589         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 590             == results.get().getResult().getStatus().getCode());
 591         verify(appcProviderLcm, times(1)).executeRequest(any());
 592     }
 593
 594     @Test
 595     public void testConfigRestore() throws Exception {
 596         // Validation success
 597         doReturn("Success").when(successlcmStatus).getMessage();
 598         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 599         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 600         doReturn(null).when(validationService).validateInput(any(), any(), any());
 601
 602         ConfigRestoreInput configRestoreInput = mock(ConfigRestoreInput.class);
 603         doReturn(newCommonHeader("request-id-test")).when(configRestoreInput).getCommonHeader();
 604         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 605             .when(configRestoreInput).getActionIdentifiers();
 606
 607         Future<RpcResult<ConfigRestoreOutput>> results = appcProviderLcm.configRestore(configRestoreInput);
 608         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 609         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 610         verify(appcProviderLcm, times(1)).executeRequest(any());
 611
 612         // Validation failed
 613         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 614         results = appcProviderLcm.configRestore(configRestoreInput);
 615         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 616         verify(appcProviderLcm, times(1)).executeRequest(any());
 617
 618         // parse exception
 619         doReturn(null).when(validationService).validateInput(any(), any(), any());
 620         doReturn(null).when(configRestoreInput).getActionIdentifiers();
 621         results = appcProviderLcm.configRestore(configRestoreInput);
 622         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 623             == results.get().getResult().getStatus().getCode());
 624         verify(appcProviderLcm, times(1)).executeRequest(any());
 625     }
 626
 627     @Test
 628     public void testTest() throws Exception {
 629         // Validation success
 630         doReturn("Success").when(successlcmStatus).getMessage();
 631         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 632         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 633         doReturn(null).when(validationService).validateInput(any(), any(), any());
 634
 635         TestInput testInput = mock(TestInput.class);
 636         doReturn(newCommonHeader("request-id-test")).when(testInput).getCommonHeader();
 637         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 638             .when(testInput).getActionIdentifiers();
 639
 640         Future<RpcResult<TestOutput>> results = appcProviderLcm.test(testInput);
 641         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 642         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 643         verify(appcProviderLcm, times(1)).executeRequest(any());
 644
 645         // Validation failed
 646         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 647         results = appcProviderLcm.test(testInput);
 648         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 649         verify(appcProviderLcm, times(1)).executeRequest(any());
 650
 651         // parse exception
 652         doReturn(null).when(validationService).validateInput(any(), any(), any());
 653         doReturn(null).when(testInput).getActionIdentifiers();
 654         results = appcProviderLcm.test(testInput);
 655         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 656             == results.get().getResult().getStatus().getCode());
 657         verify(appcProviderLcm, times(1)).executeRequest(any());
 658     }
 659
 660     @Test
 661     public void testStop() throws Exception {
 662         // Validation success
 663         doReturn("Success").when(successlcmStatus).getMessage();
 664         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 665         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 666         doReturn(null).when(validationService).validateInput(any(), any(), any());
 667
 668         StopInput stopInput = mock(StopInput.class);
 669         doReturn(newCommonHeader("request-id-stop")).when(stopInput).getCommonHeader();
 670         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 671             .when(stopInput).getActionIdentifiers();
 672
 673         Future<RpcResult<StopOutput>> results = appcProviderLcm.stop(stopInput);
 674         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 675         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 676         verify(appcProviderLcm, times(1)).executeRequest(any());
 677
 678         // Validation failed
 679         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 680         results = appcProviderLcm.stop(stopInput);
 681         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 682         verify(appcProviderLcm, times(1)).executeRequest(any());
 683
 684         // parse exception
 685         doReturn(null).when(validationService).validateInput(any(), any(), any());
 686         doReturn(null).when(stopInput).getActionIdentifiers();
 687         results = appcProviderLcm.stop(stopInput);
 688         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 689             == results.get().getResult().getStatus().getCode());
 690         verify(appcProviderLcm, times(1)).executeRequest(any());
 691     }
 692
 693     @Test
 694     public void testStart() throws Exception {
 695         // Validation success
 696         doReturn("Success").when(successlcmStatus).getMessage();
 697         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 698         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 699         doReturn(null).when(validationService).validateInput(any(), any(), any());
 700
 701         StartInput startInput = mock(StartInput.class);
 702         doReturn(newCommonHeader("request-id-start")).when(startInput).getCommonHeader();
 703         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 704             .when(startInput).getActionIdentifiers();
 705
 706         Future<RpcResult<StartOutput>> results = appcProviderLcm.start(startInput);
 707         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 708         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 709         verify(appcProviderLcm, times(1)).executeRequest(any());
 710
 711         // Validation failed
 712         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 713         results = appcProviderLcm.start(startInput);
 714         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 715         verify(appcProviderLcm, times(1)).executeRequest(any());
 716
 717         // parse exception
 718         doReturn(null).when(validationService).validateInput(any(), any(), any());
 719         doReturn(null).when(startInput).getActionIdentifiers();
 720         results = appcProviderLcm.start(startInput);
 721         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 722             == results.get().getResult().getStatus().getCode());
 723         verify(appcProviderLcm, times(1)).executeRequest(any());
 724     }
 725
 726     @Test
 727     public void testAudit() throws Exception {
 728         // Validation success
 729         doReturn("Success").when(successlcmStatus).getMessage();
 730         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 731         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 732         doReturn(null).when(validationService).validateInput(any(), any(), any());
 733
 734         AuditInput auditInput = mock(AuditInput.class);
 735         doReturn(newCommonHeader("request-id-aduit")).when(auditInput).getCommonHeader();
 736         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 737             .when(auditInput).getActionIdentifiers();
 738
 739         Future<RpcResult<AuditOutput>> results = appcProviderLcm.audit(auditInput);
 740         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 741         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 742         verify(appcProviderLcm, times(1)).executeRequest(any());
 743
 744         // Validation failed
 745         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 746         results = appcProviderLcm.audit(auditInput);
 747         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 748         verify(appcProviderLcm, times(1)).executeRequest(any());
 749
 750         // parse exception
 751         doReturn(null).when(validationService).validateInput(any(), any(), any());
 752         doReturn(null).when(auditInput).getActionIdentifiers();
 753         results = appcProviderLcm.audit(auditInput);
 754         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 755             == results.get().getResult().getStatus().getCode());
 756         verify(appcProviderLcm, times(1)).executeRequest(any());
 757     }
 758
 759     @Test
 760     public void testSoftwareUpload() throws Exception {
 761         // Validation success
 762         doReturn("Success").when(successlcmStatus).getMessage();
 763         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 764         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 765         doReturn(null).when(validationService).validateInput(any(), any(), any());
 766
 767         SoftwareUploadInput softwareUploadInput = mock(SoftwareUploadInput.class);
 768         doReturn(newCommonHeader("request-id-aduit")).when(softwareUploadInput).getCommonHeader();
 769         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 770             .when(softwareUploadInput).getActionIdentifiers();
 771
 772         Future<RpcResult<SoftwareUploadOutput>> results = appcProviderLcm.softwareUpload(softwareUploadInput);
 773         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 774         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 775         verify(appcProviderLcm, times(1)).executeRequest(any());
 776
 777         // Validation failed
 778         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 779         results = appcProviderLcm.softwareUpload(softwareUploadInput);
 780         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 781         verify(appcProviderLcm, times(1)).executeRequest(any());
 782
 783         // parse exception
 784         doReturn(null).when(validationService).validateInput(any(), any(), any());
 785         doReturn(null).when(softwareUploadInput).getActionIdentifiers();
 786         results = appcProviderLcm.softwareUpload(softwareUploadInput);
 787         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 788             == results.get().getResult().getStatus().getCode());
 789         verify(appcProviderLcm, times(1)).executeRequest(any());
 790     }
 791
 792     @Test
 793     public void testHealthCheck() throws Exception {
 794         // Validation success
 795         doReturn("Success").when(successlcmStatus).getMessage();
 796         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 797         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 798         doReturn(null).when(validationService).validateInput(any(), any(), any());
 799
 800         HealthCheckInput healthCheckInput = mock(HealthCheckInput.class);
 801         doReturn(newCommonHeader("request-id-aduit")).when(healthCheckInput).getCommonHeader();
 802         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 803             .when(healthCheckInput).getActionIdentifiers();
 804
 805         Future<RpcResult<HealthCheckOutput>> results = appcProviderLcm.healthCheck(healthCheckInput);
 806         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 807         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 808         verify(appcProviderLcm, times(1)).executeRequest(any());
 809
 810         // Validation failed
 811         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 812         results = appcProviderLcm.healthCheck(healthCheckInput);
 813         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 814         verify(appcProviderLcm, times(1)).executeRequest(any());
 815
 816         // parse exception
 817         doReturn(null).when(validationService).validateInput(any(), any(), any());
 818         doReturn(null).when(healthCheckInput).getActionIdentifiers();
 819         results = appcProviderLcm.healthCheck(healthCheckInput);
 820         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 821             == results.get().getResult().getStatus().getCode());
 822         verify(appcProviderLcm, times(1)).executeRequest(any());
 823     }
 824
 825     @Test
 826     public void testLiveUpgrade() throws Exception {
 827         // Validation success
 828         doReturn("Success").when(successlcmStatus).getMessage();
 829         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 830         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 831         doReturn(null).when(validationService).validateInput(any(), any(), any());
 832
 833         LiveUpgradeInput liveUpgradeInput = mock(LiveUpgradeInput.class);
 834         doReturn(newCommonHeader("request-id-aduit")).when(liveUpgradeInput).getCommonHeader();
 835         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 836             .when(liveUpgradeInput).getActionIdentifiers();
 837
 838         Future<RpcResult<LiveUpgradeOutput>> results = appcProviderLcm.liveUpgrade(liveUpgradeInput);
 839         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 840         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 841         verify(appcProviderLcm, times(1)).executeRequest(any());
 842
 843         // Validation failed
 844         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 845         results = appcProviderLcm.liveUpgrade(liveUpgradeInput);
 846         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 847         verify(appcProviderLcm, times(1)).executeRequest(any());
 848
 849         // parse exception
 850         doReturn(null).when(validationService).validateInput(any(), any(), any());
 851         doReturn(null).when(liveUpgradeInput).getActionIdentifiers();
 852         results = appcProviderLcm.liveUpgrade(liveUpgradeInput);
 853         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 854             == results.get().getResult().getStatus().getCode());
 855         verify(appcProviderLcm, times(1)).executeRequest(any());
 856     }
 857
 858     @Test
 859     public void testLock() throws Exception {
 860         // Validation success
 861         doReturn("Success").when(successlcmStatus).getMessage();
 862         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 863         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 864         doReturn(null).when(validationService).validateInput(any(), any(), any());
 865
 866         LockInput lockInput = mock(LockInput.class);
 867         doReturn(newCommonHeader("request-id-aduit")).when(lockInput).getCommonHeader();
 868         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 869             .when(lockInput).getActionIdentifiers();
 870
 871         Future<RpcResult<LockOutput>> results = appcProviderLcm.lock(lockInput);
 872         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 873         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 874         verify(appcProviderLcm, times(1)).executeRequest(any());
 875
 876         // Validation failed
 877         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 878         results = appcProviderLcm.lock(lockInput);
 879         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 880         verify(appcProviderLcm, times(1)).executeRequest(any());
 881
 882         // parse exception
 883         doReturn(null).when(validationService).validateInput(any(), any(), any());
 884         doReturn(null).when(lockInput).getActionIdentifiers();
 885         results = appcProviderLcm.lock(lockInput);
 886         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 887             == results.get().getResult().getStatus().getCode());
 888         verify(appcProviderLcm, times(1)).executeRequest(any());
 889     }
 890
 891     @Test
 892     public void testUnlock() throws Exception {
 893         // Validation success
 894         doReturn("Success").when(successlcmStatus).getMessage();
 895         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 896         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 897         doReturn(null).when(validationService).validateInput(any(), any(), any());
 898
 899         UnlockInput unlockInput = mock(UnlockInput.class);
 900         doReturn(newCommonHeader("request-id-aduit")).when(unlockInput).getCommonHeader();
 901         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 902             .when(unlockInput).getActionIdentifiers();
 903
 904         Future<RpcResult<UnlockOutput>> results = appcProviderLcm.unlock(unlockInput);
 905         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 906         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 907         verify(appcProviderLcm, times(1)).executeRequest(any());
 908
 909         // Validation failed
 910         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 911         results = appcProviderLcm.unlock(unlockInput);
 912         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 913         verify(appcProviderLcm, times(1)).executeRequest(any());
 914
 915         // parse exception
 916         doReturn(null).when(validationService).validateInput(any(), any(), any());
 917         doReturn(null).when(unlockInput).getActionIdentifiers();
 918         results = appcProviderLcm.unlock(unlockInput);
 919         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 920             == results.get().getResult().getStatus().getCode());
 921         verify(appcProviderLcm, times(1)).executeRequest(any());
 922     }
 923
 924     @Test
 925     public void testCheckLock() throws Exception {
 926         // Validation success
 927         doReturn("Success").when(successlcmStatus).getMessage();
 928         Map<String, String> additionalContext = new HashMap<>();
 929         additionalContext.put("locked", "true");
 930         doReturn(additionalContext).when(responseContext).getAdditionalContext();
 931         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 932         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 933         doReturn(null).when(validationService).validateInput(any(), any(), any());
 934         CheckLockInput checkLockInput = mock(CheckLockInput.class);
 935         doReturn(newCommonHeader("request-id-aduit")).when(checkLockInput).getCommonHeader();
 936         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 937             .when(checkLockInput).getActionIdentifiers();
 938
 939         Future<RpcResult<CheckLockOutput>> results = appcProviderLcm.checkLock(checkLockInput);
 940         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 941         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 942         verify(appcProviderLcm, times(1)).executeRequest(any());
 943
 944         // Validation failed
 945         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 946         results = appcProviderLcm.checkLock(checkLockInput);
 947         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 948         verify(appcProviderLcm, times(1)).executeRequest(any());
 949
 950         // parse exception
 951         doReturn(null).when(validationService).validateInput(any(), any(), any());
 952         doReturn(null).when(checkLockInput).getActionIdentifiers();
 953         results = appcProviderLcm.checkLock(checkLockInput);
 954         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 955             == results.get().getResult().getStatus().getCode());
 956         verify(appcProviderLcm, times(1)).executeRequest(any());
 957     }
 958
 959     @Test
 960     public void testConfigBackup() throws Exception {
 961         // Validation success
 962         doReturn("Success").when(successlcmStatus).getMessage();
 963         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 964         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 965         doReturn(null).when(validationService).validateInput(any(), any(), any());
 966
 967         ConfigBackupInput configBackupInput = mock(ConfigBackupInput.class);
 968         doReturn(newCommonHeader("request-id-aduit")).when(configBackupInput).getCommonHeader();
 969         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 970             .when(configBackupInput).getActionIdentifiers();
 971
 972         Future<RpcResult<ConfigBackupOutput>> results = appcProviderLcm.configBackup(configBackupInput);
 973         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 974         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 975         verify(appcProviderLcm, times(1)).executeRequest(any());
 976
 977         // Validation failed
 978         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 979         results = appcProviderLcm.configBackup(configBackupInput);
 980         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 981         verify(appcProviderLcm, times(1)).executeRequest(any());
 982
 983         // parse exception
 984         doReturn(null).when(validationService).validateInput(any(), any(), any());
 985         doReturn(null).when(configBackupInput).getActionIdentifiers();
 986         results = appcProviderLcm.configBackup(configBackupInput);
 987         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 988             == results.get().getResult().getStatus().getCode());
 989         verify(appcProviderLcm, times(1)).executeRequest(any());
 990     }
 991
 992     @Test
 993     public void testConfigBackupDelete() throws Exception {
 994         // Validation success
 995         doReturn("Success").when(successlcmStatus).getMessage();
 996         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 997         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 998         doReturn(null).when(validationService).validateInput(any(), any(), any());
 999
1000         ConfigBackupDeleteInput configBackupDeleteInput = mock(ConfigBackupDeleteInput.class);
1001         doReturn(newCommonHeader("request-id-aduit")).when(configBackupDeleteInput).getCommonHeader();
1002         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
1003             .when(configBackupDeleteInput).getActionIdentifiers();
1004
1005         Future<RpcResult<ConfigBackupDeleteOutput>> results = appcProviderLcm.configBackupDelete
1006             (configBackupDeleteInput);
1007         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
1008         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
1009         verify(appcProviderLcm, times(1)).executeRequest(any());
1010
1011         // Validation failed
1012         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
1013         results = appcProviderLcm.configBackupDelete(configBackupDeleteInput);
1014         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
1015         verify(appcProviderLcm, times(1)).executeRequest(any());
1016
1017         // parse exception
1018         doReturn(null).when(validationService).validateInput(any(), any(), any());
1019         doReturn(null).when(configBackupDeleteInput).getActionIdentifiers();
1020         results = appcProviderLcm.configBackupDelete(configBackupDeleteInput);
1021         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
1022             == results.get().getResult().getStatus().getCode());
1023         verify(appcProviderLcm, times(1)).executeRequest(any());
1024     }
1025
1026     @Test
1027     public void testConfigExport() throws Exception {
1028         // Validation success
1029         doReturn("Success").when(successlcmStatus).getMessage();
1030         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
1031         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
1032         doReturn(null).when(validationService).validateInput(any(), any(), any());
1033
1034         ConfigExportInput configExportInput = mock(ConfigExportInput.class);
1035         doReturn(newCommonHeader("request-id-aduit")).when(configExportInput).getCommonHeader();
1036         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
1037             .when(configExportInput).getActionIdentifiers();
1038
1039         Future<RpcResult<ConfigExportOutput>> results = appcProviderLcm.configExport
1040             (configExportInput);
1041         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
1042         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
1043         verify(appcProviderLcm, times(1)).executeRequest(any());
1044
1045         // Validation failed
1046         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
1047         results = appcProviderLcm.configExport(configExportInput);
1048         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
1049         verify(appcProviderLcm, times(1)).executeRequest(any());
1050
1051         // parse exception
1052         doReturn(null).when(validationService).validateInput(any(), any(), any());
1053         doReturn(null).when(configExportInput).getActionIdentifiers();
1054         results = appcProviderLcm.configExport(configExportInput);
1055         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
1056             == results.get().getResult().getStatus().getCode());
1057         verify(appcProviderLcm, times(1)).executeRequest(any());
1058     }
1059
1060     @Test
1061     public void testStopApplication() throws Exception {
1062         // Validation success
1063         doReturn("Success").when(successlcmStatus).getMessage();
1064         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
1065         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
1066         doReturn(null).when(validationService).validateInput(any(), any(), any());
1067
1068         StopApplicationInput stopApplicationInput = mock(StopApplicationInput.class);
1069         doReturn(newCommonHeader("request-id-aduit")).when(stopApplicationInput).getCommonHeader();
1070         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
1071             .when(stopApplicationInput).getActionIdentifiers();
1072
1073         Future<RpcResult<StopApplicationOutput>> results = appcProviderLcm.stopApplication
1074             (stopApplicationInput);
1075         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
1076         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
1077         verify(appcProviderLcm, times(1)).executeRequest(any());
1078
1079         // Validation failed
1080         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
1081         results = appcProviderLcm.stopApplication(stopApplicationInput);
1082         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
1083         verify(appcProviderLcm, times(1)).executeRequest(any());
1084
1085         // parse exception
1086         doReturn(null).when(validationService).validateInput(any(), any(), any());
1087         doReturn(null).when(stopApplicationInput).getActionIdentifiers();
1088         results = appcProviderLcm.stopApplication(stopApplicationInput);
1089         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
1090             == results.get().getResult().getStatus().getCode());
1091         verify(appcProviderLcm, times(1)).executeRequest(any());
1092     }
1093
1094     @After
1095     public void tearDown() throws Exception {
1096         if (appcProviderLcm != null) {
1097             appcProviderLcm.close();
1098         }
1099     }
1100
1101     private ActionIdentifiers newActionIdentifier(String vnfId, String vnfcId, String vserverId) {
1102         ActionIdentifiersBuilder actionIdentifiersBuilder = new ActionIdentifiersBuilder();
1103         actionIdentifiersBuilder.setVnfId(vnfId);
1104         actionIdentifiersBuilder.setVnfcName(vnfcId);
1105         actionIdentifiersBuilder.setVserverId(vserverId);
1106         return actionIdentifiersBuilder.build();
1107     }
1108
1109     private CommonHeader newCommonHeader(String requestId) {
1110         CommonHeaderBuilder commonHeaderBuilder = new CommonHeaderBuilder();
1111         commonHeaderBuilder.setRequestId(requestId);
1112         commonHeaderBuilder.setApiVer("2.0.0");
1113         commonHeaderBuilder.setOriginatorId("originatortest");
1114         commonHeaderBuilder.setTimestamp(ZULU.getDefaultInstance(LocalDateTime.now(Clock.systemUTC()).toString() +
1115             "Z"));
1116         return commonHeaderBuilder.build();
1117     }
1118 }