appc-provider/appc-provider-bundle/src/test/java/org/onap/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.AttachVolumeInput;
  40 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AttachVolumeOutput;
  41 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AttachVolumeOutputBuilder;
  42 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AuditInput;
  43 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AuditOutput;
  44 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.CheckLockInput;
  45 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.CheckLockOutput;
  46 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigBackupDeleteInput;
  47 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigBackupDeleteOutput;
  48 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigBackupInput;
  49 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigBackupOutput;
  50 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigExportInput;
  51 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigExportOutput;
  52 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigModifyInput;
  53 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigModifyOutput;
  54 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigRestoreInput;
  55 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigRestoreOutput;
  56 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigScaleoutInput;
  57 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigScaleoutOutput;
  58 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigureInput;
  59 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigureOutput;
  60 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.DetachVolumeInput;
  61 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.DetachVolumeOutput;
  62 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.DetachVolumeOutputBuilder;
  63 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.EvacuateInput;
  64 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.EvacuateOutput;
  65 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.HealthCheckInput;
  66 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.HealthCheckOutput;
  67 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.LiveUpgradeInput;
  68 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.LiveUpgradeOutput;
  69 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.LockInput;
  70 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.LockOutput;
  71 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.MigrateInput;
  72 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.MigrateOutput;
  73 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.QueryInput;
  74 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.QueryOutput;
  75 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.QueryOutputBuilder;
  76 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.QuiesceTrafficInput;
  77 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.QuiesceTrafficOutput;
  78 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.QuiesceTrafficOutputBuilder;
  79 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ResumeTrafficInput;
  80 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ResumeTrafficOutput;
  81 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ResumeTrafficOutputBuilder;
  82 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradePreCheckInput;
  83 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradePreCheckOutput;
  84 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradePreCheckOutputBuilder;
  85 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeSoftwareInput;
  86 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeSoftwareOutput;
  87 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeSoftwareOutputBuilder;
  88 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradePostCheckInput;
  89 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradePostCheckOutput;
  90 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradePostCheckOutputBuilder;
  91 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeBackupInput;
  92 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeBackupOutput;
  93 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeBackupOutputBuilder;
  94 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeBackoutInput;
  95 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeBackoutOutput;
  96 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeBackoutOutputBuilder;
  97 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RebootInput;
  98 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RebootOutput;
  99 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RebootOutputBuilder;
 100 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RebuildInput;
 101 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RebuildOutput;
 102 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RestartInput;
 103 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RestartOutput;
 104 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RollbackInput;
 105 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RollbackOutput;
 106 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SnapshotInput;
 107 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SnapshotOutput;
 108 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SoftwareUploadInput;
 109 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SoftwareUploadOutput;
 110 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StartApplicationInput;
 111 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StartApplicationOutput;
 112 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StartInput;
 113 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StartOutput;
 114 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StopApplicationInput;
 115 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StopApplicationOutput;
 116 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StopInput;
 117 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StopOutput;
 118 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SyncInput;
 119 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SyncOutput;
 120 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.TerminateInput;
 121 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.TerminateOutput;
 122 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.TestInput;
 123 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.TestOutput;
 124 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UnlockInput;
 125 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UnlockOutput;
 126 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ZULU;
 127 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.action.identifiers.ActionIdentifiers;
 128 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.action.identifiers.ActionIdentifiersBuilder;
 129 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.common.header.CommonHeader;
 130 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.common.header.CommonHeaderBuilder;
 131 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.status.Status;
 132 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.status.StatusBuilder;
 133 import org.opendaylight.yangtools.yang.common.RpcResult;
 134 import org.onap.appc.domainmodel.lcm.ResponseContext;
 135 import org.onap.appc.executor.objects.LCMCommandStatus;
 136 import org.onap.appc.provider.lcm.service.*;
 137 import org.onap.appc.provider.lcm.util.ValidationService;
 138 import org.onap.appc.requesthandler.objects.RequestHandlerOutput;
 139 import org.osgi.framework.FrameworkUtil;
 140 import org.powermock.api.mockito.PowerMockito;
 141 import org.powermock.core.classloader.annotations.PrepareForTest;
 142 import org.powermock.modules.junit4.PowerMockRunner;
 143 import org.powermock.reflect.Whitebox;
 144
 145 import java.time.Clock;
 146 import java.time.LocalDateTime;
 147 import java.util.HashMap;
 148 import java.util.Map;
 149 import java.util.concurrent.ExecutorService;
 150 import java.util.concurrent.Executors;
 151 import java.util.concurrent.Future;
 152
 153 import static org.mockito.Matchers.any;
 154 import static org.mockito.Mockito.doReturn;
 155 import static org.mockito.Mockito.mock;
 156 import static org.mockito.Mockito.spy;
 157 import static org.mockito.Mockito.times;
 158 import static org.mockito.Mockito.verify;
 159 import static org.mockito.Mockito.when;
 160 import static org.powermock.api.mockito.PowerMockito.mockStatic;
 161 import static org.powermock.api.mockito.PowerMockito.whenNew;
 162
 163 /**
 164  * Integration Test class for AppcProviderLcm.
 165  */
 166 @RunWith(PowerMockRunner.class)
 167 @PrepareForTest({FrameworkUtil.class, AppcProviderLcm.class, QueryService.class, VolumeService.class,
 168     QuiesceTrafficService.class, ValidationService.class})
 169 public class AppcProviderLcmTest extends AbstractDataBrokerTest {
 170     private Status successStatus = new StatusBuilder().setCode(400).setMessage("success").build();
 171     private Status failStatus = new StatusBuilder().setCode(401).setMessage("failure").build();
 172
 173     private AppcProviderLcm appcProviderLcm;
 174     private DataBroker dataBroker;
 175     @Spy
 176     private ValidationService validationService = ValidationService.getInstance();
 177     @Mock
 178     private RequestHandlerOutput requestHandlerOutput;
 179     @Mock
 180     private ResponseContext responseContext;
 181     @Mock
 182     private org.onap.appc.domainmodel.lcm.Status successlcmStatus;
 183
 184     /**
 185      * The @Before annotation is defined in the AbstractDataBrokerTest class. The method setupWithDataBroker is invoked
 186      * from inside the @Before method and is used to initialize the databroker with objects for a test runs. In our case
 187      * we use this oportunity to create an instance of our provider and initialize it (which registers it as a listener
 188      * etc). This method runs before every @Test method below.
 189      */
 190     @Override
 191     protected void setupWithDataBroker(DataBroker dataBroker) {
 192         super.setupWithDataBroker(dataBroker);
 193
 194         this.dataBroker = dataBroker;
 195     }
 196
 197     @Before
 198     public void setUp() throws Exception {
 199         //mock appcProviderLcm
 200         NotificationProviderService nps = mock(NotificationProviderService.class);
 201         RpcProviderRegistry registry = mock(RpcProviderRegistry.class);
 202         BindingAwareBroker.RpcRegistration rpcRegistration = mock(BindingAwareBroker.RpcRegistration.class);
 203         PowerMockito.doReturn(rpcRegistration).when(registry).addRpcImplementation(any(), any());
 204         appcProviderLcm = spy(new AppcProviderLcm(dataBroker, nps, registry));
 205         //mock validationService
 206         mockStatic(ValidationService.class);
 207         PowerMockito.when(ValidationService.getInstance()).thenReturn(validationService);
 208
 209         doReturn(successlcmStatus).when(responseContext).getStatus();
 210         doReturn(400).when(successlcmStatus).getCode();
 211         doReturn("success").when(successlcmStatus).getMessage();
 212     }
 213
 214     @Test
 215     public void testConstructor() throws Exception {
 216         ExecutorService executorService = Whitebox.getInternalState(appcProviderLcm, "executor");
 217         Assert.assertNotNull(executorService);
 218         BindingAwareBroker.RpcRegistration internalRpcRegistration = Whitebox.getInternalState(appcProviderLcm,
 219             "rpcRegistration");
 220         Assert.assertNotNull(internalRpcRegistration);
 221     }
 222
 223     @Test
 224     public void testClose() throws Exception {
 225         ExecutorService executorService = spy(Executors.newFixedThreadPool(1));
 226         Whitebox.setInternalState(appcProviderLcm, "executor", executorService);
 227         BindingAwareBroker.RpcRegistration rpcRegistration = mock(BindingAwareBroker.RpcRegistration.class);
 228         Whitebox.setInternalState(appcProviderLcm, "rpcRegistration", rpcRegistration);
 229         appcProviderLcm.close();
 230
 231         verify(executorService, times(1)).shutdown();
 232         verify(rpcRegistration, times(1)).close();
 233     }
 234
 235     @Test
 236     public void testRebuild() throws Exception {
 237         // Validation success
 238         doReturn("Success").when(successlcmStatus).getMessage();
 239         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 240         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 241         doReturn(null).when(validationService).validateInput(any(), any(), any());
 242
 243         RebuildInput rebuildInput = mock(RebuildInput.class);
 244         doReturn(newCommonHeader("request-id-test")).when(rebuildInput).getCommonHeader();
 245         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 246             .when(rebuildInput).getActionIdentifiers();
 247
 248         Future<RpcResult<RebuildOutput>> results = appcProviderLcm.rebuild(rebuildInput);
 249         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 250         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 251         verify(appcProviderLcm, times(1)).executeRequest(any());
 252
 253         // Validation failed
 254         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 255         results = appcProviderLcm.rebuild(rebuildInput);
 256         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 257         verify(appcProviderLcm, times(1)).executeRequest(any());
 258
 259         // parse exception
 260         doReturn(null).when(validationService).validateInput(any(), any(), any());
 261         doReturn(null).when(rebuildInput).getActionIdentifiers();
 262         results = appcProviderLcm.rebuild(rebuildInput);
 263         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 264             == results.get().getResult().getStatus().getCode());
 265         verify(appcProviderLcm, times(1)).executeRequest(any());
 266     }
 267
 268     @Test
 269     public void testRestart() throws Exception {
 270         // Validation success
 271         doReturn("Success").when(successlcmStatus).getMessage();
 272         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 273         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 274         doReturn(null).when(validationService).validateInput(any(), any(), any());
 275
 276         RestartInput restartInput = mock(RestartInput.class);
 277         doReturn(newCommonHeader("request-id-test")).when(restartInput).getCommonHeader();
 278         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 279             .when(restartInput).getActionIdentifiers();
 280
 281         Future<RpcResult<RestartOutput>> results = appcProviderLcm.restart(restartInput);
 282         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 283         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 284         verify(appcProviderLcm, times(1)).executeRequest(any());
 285
 286         // Validation failed
 287         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 288         results = appcProviderLcm.restart(restartInput);
 289         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 290         verify(appcProviderLcm, times(1)).executeRequest(any());
 291
 292         // parse exception
 293         doReturn(null).when(validationService).validateInput(any(), any(), any());
 294         doReturn(null).when(restartInput).getActionIdentifiers();
 295         results = appcProviderLcm.restart(restartInput);
 296         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 297             == results.get().getResult().getStatus().getCode());
 298         verify(appcProviderLcm, times(1)).executeRequest(any());
 299     }
 300
 301     @Test
 302     public void testStartApplication() throws Exception {
 303         // Validation success
 304         doReturn("Success").when(successlcmStatus).getMessage();
 305         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 306         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 307         doReturn(null).when(validationService).validateInput(any(), any(), any());
 308
 309         StartApplicationInput startApplicationInput = mock(StartApplicationInput.class);
 310         doReturn(newCommonHeader("request-id-test")).when(startApplicationInput).getCommonHeader();
 311         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 312             .when(startApplicationInput).getActionIdentifiers();
 313
 314         Future<RpcResult<StartApplicationOutput>> results = appcProviderLcm.startApplication(startApplicationInput);
 315         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 316         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 317         verify(appcProviderLcm, times(1)).executeRequest(any());
 318
 319         // Validation failed
 320         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 321         results = appcProviderLcm.startApplication(startApplicationInput);
 322         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 323         verify(appcProviderLcm, times(1)).executeRequest(any());
 324
 325         // parse exception
 326         doReturn(null).when(validationService).validateInput(any(), any(), any());
 327         doReturn(null).when(startApplicationInput).getActionIdentifiers();
 328         results = appcProviderLcm.startApplication(startApplicationInput);
 329         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 330             == results.get().getResult().getStatus().getCode());
 331         verify(appcProviderLcm, times(1)).executeRequest(any());
 332     }
 333
 334     @Test
 335     public void testMigrate() throws Exception {
 336         // Validation success
 337         doReturn("Success").when(successlcmStatus).getMessage();
 338         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 339         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 340         doReturn(null).when(validationService).validateInput(any(), any(), any());
 341
 342         MigrateInput migrateInput = mock(MigrateInput.class);
 343         doReturn(newCommonHeader("request-id-test")).when(migrateInput).getCommonHeader();
 344         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 345             .when(migrateInput).getActionIdentifiers();
 346
 347         Future<RpcResult<MigrateOutput>> results = appcProviderLcm.migrate(migrateInput);
 348         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 349         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 350         verify(appcProviderLcm, times(1)).executeRequest(any());
 351
 352         // Validation failed
 353         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 354         results = appcProviderLcm.migrate(migrateInput);
 355         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 356         verify(appcProviderLcm, times(1)).executeRequest(any());
 357
 358         // parse exception
 359         doReturn(null).when(validationService).validateInput(any(), any(), any());
 360         doReturn(null).when(migrateInput).getActionIdentifiers();
 361         results = appcProviderLcm.migrate(migrateInput);
 362         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 363             == results.get().getResult().getStatus().getCode());
 364         verify(appcProviderLcm, times(1)).executeRequest(any());
 365     }
 366
 367     @Test
 368     public void testEvacuate() throws Exception {
 369         // Validation success
 370         doReturn("Success").when(successlcmStatus).getMessage();
 371         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 372         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 373         doReturn(null).when(validationService).validateInput(any(), any(), any());
 374
 375         EvacuateInput evacuateInput = mock(EvacuateInput.class);
 376         doReturn(newCommonHeader("request-id-test")).when(evacuateInput).getCommonHeader();
 377         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 378             .when(evacuateInput).getActionIdentifiers();
 379
 380         Future<RpcResult<EvacuateOutput>> results = appcProviderLcm.evacuate(evacuateInput);
 381         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 382         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 383         verify(appcProviderLcm, times(1)).executeRequest(any());
 384
 385         // Validation failed
 386         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 387         results = appcProviderLcm.evacuate(evacuateInput);
 388         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 389         verify(appcProviderLcm, times(1)).executeRequest(any());
 390
 391         // parse exception
 392         doReturn(null).when(validationService).validateInput(any(), any(), any());
 393         doReturn(null).when(evacuateInput).getActionIdentifiers();
 394         results = appcProviderLcm.evacuate(evacuateInput);
 395         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 396             == results.get().getResult().getStatus().getCode());
 397         verify(appcProviderLcm, times(1)).executeRequest(any());
 398     }
 399
 400     @Test
 401     public void testSnapshot() throws Exception {
 402         // Validation success
 403         doReturn("Success").when(successlcmStatus).getMessage();
 404         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 405         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 406         doReturn(null).when(validationService).validateInput(any(), any(), any());
 407
 408         SnapshotInput snapshotInput = mock(SnapshotInput.class);
 409         doReturn(newCommonHeader("request-id-test")).when(snapshotInput).getCommonHeader();
 410         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 411             .when(snapshotInput).getActionIdentifiers();
 412
 413         Future<RpcResult<SnapshotOutput>> results = appcProviderLcm.snapshot(snapshotInput);
 414         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 415         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 416         verify(appcProviderLcm, times(1)).executeRequest(any());
 417
 418         // Validation failed
 419         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 420         results = appcProviderLcm.snapshot(snapshotInput);
 421         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 422         verify(appcProviderLcm, times(1)).executeRequest(any());
 423
 424         // parse exception
 425         doReturn(null).when(validationService).validateInput(any(), any(), any());
 426         doReturn(null).when(snapshotInput).getActionIdentifiers();
 427         results = appcProviderLcm.snapshot(snapshotInput);
 428         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 429             == results.get().getResult().getStatus().getCode());
 430         verify(appcProviderLcm, times(1)).executeRequest(any());
 431     }
 432
 433     @Test
 434     public void testRollback() throws Exception {
 435         // Validation success
 436         doReturn("Success").when(successlcmStatus).getMessage();
 437         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 438         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 439         doReturn(null).when(validationService).validateInput(any(), any(), any());
 440
 441         RollbackInput rollbackInput = mock(RollbackInput.class);
 442         doReturn(newCommonHeader("request-id-test")).when(rollbackInput).getCommonHeader();
 443         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 444             .when(rollbackInput).getActionIdentifiers();
 445
 446         Future<RpcResult<RollbackOutput>> results = appcProviderLcm.rollback(rollbackInput);
 447         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 448         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 449         verify(appcProviderLcm, times(1)).executeRequest(any());
 450
 451         // Validation failed
 452         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 453         results = appcProviderLcm.rollback(rollbackInput);
 454         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 455         verify(appcProviderLcm, times(1)).executeRequest(any());
 456
 457         // parse exception
 458         doReturn(null).when(validationService).validateInput(any(), any(), any());
 459         doReturn(null).when(rollbackInput).getActionIdentifiers();
 460         results = appcProviderLcm.rollback(rollbackInput);
 461         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 462             == results.get().getResult().getStatus().getCode());
 463         verify(appcProviderLcm, times(1)).executeRequest(any());
 464     }
 465
 466     @Test
 467     public void testSync() throws Exception {
 468         // Validation success
 469         doReturn("Success").when(successlcmStatus).getMessage();
 470         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 471         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 472         doReturn(null).when(validationService).validateInput(any(), any(), any());
 473
 474         SyncInput syncInput = mock(SyncInput.class);
 475         doReturn(newCommonHeader("request-id-test")).when(syncInput).getCommonHeader();
 476         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 477             .when(syncInput).getActionIdentifiers();
 478
 479         Future<RpcResult<SyncOutput>> results = appcProviderLcm.sync(syncInput);
 480         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 481         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 482         verify(appcProviderLcm, times(1)).executeRequest(any());
 483
 484         // Validation failed
 485         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 486         results = appcProviderLcm.sync(syncInput);
 487         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 488         verify(appcProviderLcm, times(1)).executeRequest(any());
 489
 490         // parse exception
 491         doReturn(null).when(validationService).validateInput(any(), any(), any());
 492         doReturn(null).when(syncInput).getActionIdentifiers();
 493         results = appcProviderLcm.sync(syncInput);
 494         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 495             == results.get().getResult().getStatus().getCode());
 496         verify(appcProviderLcm, times(1)).executeRequest(any());
 497     }
 498
 499     @Test
 500     public void testTerminate() throws Exception {
 501         // Validation success
 502         doReturn("Success").when(successlcmStatus).getMessage();
 503         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 504         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 505         doReturn(null).when(validationService).validateInput(any(), any(), any());
 506
 507         TerminateInput terminateInput = mock(TerminateInput.class);
 508         doReturn(newCommonHeader("request-id-test")).when(terminateInput).getCommonHeader();
 509         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 510             .when(terminateInput).getActionIdentifiers();
 511
 512         Future<RpcResult<TerminateOutput>> results = appcProviderLcm.terminate(terminateInput);
 513         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 514         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 515         verify(appcProviderLcm, times(1)).executeRequest(any());
 516
 517         // Validation failed
 518         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 519         results = appcProviderLcm.terminate(terminateInput);
 520         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 521         verify(appcProviderLcm, times(1)).executeRequest(any());
 522
 523         // parse exception
 524         doReturn(null).when(validationService).validateInput(any(), any(), any());
 525         doReturn(null).when(terminateInput).getActionIdentifiers();
 526         results = appcProviderLcm.terminate(terminateInput);
 527         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 528             == results.get().getResult().getStatus().getCode());
 529         verify(appcProviderLcm, times(1)).executeRequest(any());
 530     }
 531
 532     @Test
 533     public void testConfigure() throws Exception {
 534         // Validation success
 535         doReturn("Success").when(successlcmStatus).getMessage();
 536         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 537         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 538         doReturn(null).when(validationService).validateInput(any(), any(), any());
 539
 540         ConfigureInput configureInput = mock(ConfigureInput.class);
 541         doReturn(newCommonHeader("request-id-test")).when(configureInput).getCommonHeader();
 542         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 543             .when(configureInput).getActionIdentifiers();
 544
 545         Future<RpcResult<ConfigureOutput>> results = appcProviderLcm.configure(configureInput);
 546         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 547         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 548         verify(appcProviderLcm, times(1)).executeRequest(any());
 549
 550         // Validation failed
 551         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 552         results = appcProviderLcm.configure(configureInput);
 553         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 554         verify(appcProviderLcm, times(1)).executeRequest(any());
 555
 556         // parse exception
 557         doReturn(null).when(validationService).validateInput(any(), any(), any());
 558         doReturn(null).when(configureInput).getActionIdentifiers();
 559         results = appcProviderLcm.configure(configureInput);
 560         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 561             == results.get().getResult().getStatus().getCode());
 562         verify(appcProviderLcm, times(1)).executeRequest(any());
 563     }
 564
 565     @Test
 566     public void testConfigModify() throws Exception {
 567         // Validation success
 568         doReturn("Success").when(successlcmStatus).getMessage();
 569         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 570         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 571         doReturn(null).when(validationService).validateInput(any(), any(), any());
 572
 573         ConfigModifyInput configModifyInput = mock(ConfigModifyInput.class);
 574         doReturn(newCommonHeader("request-id-test")).when(configModifyInput).getCommonHeader();
 575         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 576             .when(configModifyInput).getActionIdentifiers();
 577
 578         Future<RpcResult<ConfigModifyOutput>> results = appcProviderLcm.configModify(configModifyInput);
 579         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 580         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 581         verify(appcProviderLcm, times(1)).executeRequest(any());
 582
 583         // Validation failed
 584         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 585         results = appcProviderLcm.configModify(configModifyInput);
 586         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 587         verify(appcProviderLcm, times(1)).executeRequest(any());
 588
 589         // parse exception
 590         doReturn(null).when(validationService).validateInput(any(), any(), any());
 591         doReturn(null).when(configModifyInput).getActionIdentifiers();
 592         results = appcProviderLcm.configModify(configModifyInput);
 593         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 594             == results.get().getResult().getStatus().getCode());
 595         verify(appcProviderLcm, times(1)).executeRequest(any());
 596     }
 597
 598     @Test
 599     public void testConfigScaleout() throws Exception {
 600         // Validation success
 601         doReturn("Success").when(successlcmStatus).getMessage();
 602         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 603         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 604         doReturn(null).when(validationService).validateInput(any(), any(), any());
 605
 606         ConfigScaleoutInput configScaleoutInput = mock(ConfigScaleoutInput.class);
 607         doReturn(newCommonHeader("request-id-test")).when(configScaleoutInput).getCommonHeader();
 608         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 609             .when(configScaleoutInput).getActionIdentifiers();
 610
 611         Future<RpcResult<ConfigScaleoutOutput>> results = appcProviderLcm.configScaleout(configScaleoutInput);
 612         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 613         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 614         verify(appcProviderLcm, times(1)).executeRequest(any());
 615
 616         // Validation failed
 617         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 618         results = appcProviderLcm.configScaleout(configScaleoutInput);
 619         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 620         verify(appcProviderLcm, times(1)).executeRequest(any());
 621
 622         // parse exception
 623         doReturn(null).when(validationService).validateInput(any(), any(), any());
 624         doReturn(null).when(configScaleoutInput).getActionIdentifiers();
 625         results = appcProviderLcm.configScaleout(configScaleoutInput);
 626         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 627             == results.get().getResult().getStatus().getCode());
 628         verify(appcProviderLcm, times(1)).executeRequest(any());
 629     }
 630
 631     @Test
 632     public void testConfigRestore() throws Exception {
 633         // Validation success
 634         doReturn("Success").when(successlcmStatus).getMessage();
 635         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 636         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 637         doReturn(null).when(validationService).validateInput(any(), any(), any());
 638
 639         ConfigRestoreInput configRestoreInput = mock(ConfigRestoreInput.class);
 640         doReturn(newCommonHeader("request-id-test")).when(configRestoreInput).getCommonHeader();
 641         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 642             .when(configRestoreInput).getActionIdentifiers();
 643
 644         Future<RpcResult<ConfigRestoreOutput>> results = appcProviderLcm.configRestore(configRestoreInput);
 645         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 646         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 647         verify(appcProviderLcm, times(1)).executeRequest(any());
 648
 649         // Validation failed
 650         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 651         results = appcProviderLcm.configRestore(configRestoreInput);
 652         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 653         verify(appcProviderLcm, times(1)).executeRequest(any());
 654
 655         // parse exception
 656         doReturn(null).when(validationService).validateInput(any(), any(), any());
 657         doReturn(null).when(configRestoreInput).getActionIdentifiers();
 658         results = appcProviderLcm.configRestore(configRestoreInput);
 659         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 660             == results.get().getResult().getStatus().getCode());
 661         verify(appcProviderLcm, times(1)).executeRequest(any());
 662     }
 663
 664     @Test
 665     public void testTest() throws Exception {
 666         // Validation success
 667         doReturn("Success").when(successlcmStatus).getMessage();
 668         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 669         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 670         doReturn(null).when(validationService).validateInput(any(), any(), any());
 671
 672         TestInput testInput = mock(TestInput.class);
 673         doReturn(newCommonHeader("request-id-test")).when(testInput).getCommonHeader();
 674         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 675             .when(testInput).getActionIdentifiers();
 676
 677         Future<RpcResult<TestOutput>> results = appcProviderLcm.test(testInput);
 678         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 679         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 680         verify(appcProviderLcm, times(1)).executeRequest(any());
 681
 682         // Validation failed
 683         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 684         results = appcProviderLcm.test(testInput);
 685         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 686         verify(appcProviderLcm, times(1)).executeRequest(any());
 687
 688         // parse exception
 689         doReturn(null).when(validationService).validateInput(any(), any(), any());
 690         doReturn(null).when(testInput).getActionIdentifiers();
 691         results = appcProviderLcm.test(testInput);
 692         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 693             == results.get().getResult().getStatus().getCode());
 694         verify(appcProviderLcm, times(1)).executeRequest(any());
 695     }
 696
 697     @Test
 698     public void testStop() throws Exception {
 699         // Validation success
 700         doReturn("Success").when(successlcmStatus).getMessage();
 701         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 702         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 703         doReturn(null).when(validationService).validateInput(any(), any(), any());
 704
 705         StopInput stopInput = mock(StopInput.class);
 706         doReturn(newCommonHeader("request-id-stop")).when(stopInput).getCommonHeader();
 707         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 708             .when(stopInput).getActionIdentifiers();
 709
 710         Future<RpcResult<StopOutput>> results = appcProviderLcm.stop(stopInput);
 711         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 712         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 713         verify(appcProviderLcm, times(1)).executeRequest(any());
 714
 715         // Validation failed
 716         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 717         results = appcProviderLcm.stop(stopInput);
 718         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 719         verify(appcProviderLcm, times(1)).executeRequest(any());
 720
 721         // parse exception
 722         doReturn(null).when(validationService).validateInput(any(), any(), any());
 723         doReturn(null).when(stopInput).getActionIdentifiers();
 724         results = appcProviderLcm.stop(stopInput);
 725         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 726             == results.get().getResult().getStatus().getCode());
 727         verify(appcProviderLcm, times(1)).executeRequest(any());
 728     }
 729
 730     @Test
 731     public void testStart() throws Exception {
 732         // Validation success
 733         doReturn("Success").when(successlcmStatus).getMessage();
 734         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 735         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 736         doReturn(null).when(validationService).validateInput(any(), any(), any());
 737
 738         StartInput startInput = mock(StartInput.class);
 739         doReturn(newCommonHeader("request-id-start")).when(startInput).getCommonHeader();
 740         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 741             .when(startInput).getActionIdentifiers();
 742
 743         Future<RpcResult<StartOutput>> results = appcProviderLcm.start(startInput);
 744         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 745         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 746         verify(appcProviderLcm, times(1)).executeRequest(any());
 747
 748         // Validation failed
 749         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 750         results = appcProviderLcm.start(startInput);
 751         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 752         verify(appcProviderLcm, times(1)).executeRequest(any());
 753
 754         // parse exception
 755         doReturn(null).when(validationService).validateInput(any(), any(), any());
 756         doReturn(null).when(startInput).getActionIdentifiers();
 757         results = appcProviderLcm.start(startInput);
 758         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 759             == results.get().getResult().getStatus().getCode());
 760         verify(appcProviderLcm, times(1)).executeRequest(any());
 761     }
 762
 763     @Test
 764     public void testAudit() throws Exception {
 765         // Validation success
 766         doReturn("Success").when(successlcmStatus).getMessage();
 767         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 768         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 769         doReturn(null).when(validationService).validateInput(any(), any(), any());
 770
 771         AuditInput auditInput = mock(AuditInput.class);
 772         doReturn(newCommonHeader("request-id-aduit")).when(auditInput).getCommonHeader();
 773         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 774             .when(auditInput).getActionIdentifiers();
 775
 776         Future<RpcResult<AuditOutput>> results = appcProviderLcm.audit(auditInput);
 777         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 778         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 779         verify(appcProviderLcm, times(1)).executeRequest(any());
 780
 781         // Validation failed
 782         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 783         results = appcProviderLcm.audit(auditInput);
 784         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 785         verify(appcProviderLcm, times(1)).executeRequest(any());
 786
 787         // parse exception
 788         doReturn(null).when(validationService).validateInput(any(), any(), any());
 789         doReturn(null).when(auditInput).getActionIdentifiers();
 790         results = appcProviderLcm.audit(auditInput);
 791         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 792             == results.get().getResult().getStatus().getCode());
 793         verify(appcProviderLcm, times(1)).executeRequest(any());
 794     }
 795
 796     @Test
 797     public void testSoftwareUpload() throws Exception {
 798         // Validation success
 799         doReturn("Success").when(successlcmStatus).getMessage();
 800         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 801         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 802         doReturn(null).when(validationService).validateInput(any(), any(), any());
 803
 804         SoftwareUploadInput softwareUploadInput = mock(SoftwareUploadInput.class);
 805         doReturn(newCommonHeader("request-id-aduit")).when(softwareUploadInput).getCommonHeader();
 806         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 807             .when(softwareUploadInput).getActionIdentifiers();
 808
 809         Future<RpcResult<SoftwareUploadOutput>> results = appcProviderLcm.softwareUpload(softwareUploadInput);
 810         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 811         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 812         verify(appcProviderLcm, times(1)).executeRequest(any());
 813
 814         // Validation failed
 815         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 816         results = appcProviderLcm.softwareUpload(softwareUploadInput);
 817         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 818         verify(appcProviderLcm, times(1)).executeRequest(any());
 819
 820         // parse exception
 821         doReturn(null).when(validationService).validateInput(any(), any(), any());
 822         doReturn(null).when(softwareUploadInput).getActionIdentifiers();
 823         results = appcProviderLcm.softwareUpload(softwareUploadInput);
 824         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 825             == results.get().getResult().getStatus().getCode());
 826         verify(appcProviderLcm, times(1)).executeRequest(any());
 827     }
 828
 829     @Test
 830     public void testHealthCheck() throws Exception {
 831         // Validation success
 832         doReturn("Success").when(successlcmStatus).getMessage();
 833         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 834         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 835         doReturn(null).when(validationService).validateInput(any(), any(), any());
 836
 837         HealthCheckInput healthCheckInput = mock(HealthCheckInput.class);
 838         doReturn(newCommonHeader("request-id-aduit")).when(healthCheckInput).getCommonHeader();
 839         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 840             .when(healthCheckInput).getActionIdentifiers();
 841
 842         Future<RpcResult<HealthCheckOutput>> results = appcProviderLcm.healthCheck(healthCheckInput);
 843         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 844         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 845         verify(appcProviderLcm, times(1)).executeRequest(any());
 846
 847         // Validation failed
 848         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 849         results = appcProviderLcm.healthCheck(healthCheckInput);
 850         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 851         verify(appcProviderLcm, times(1)).executeRequest(any());
 852
 853         // parse exception
 854         doReturn(null).when(validationService).validateInput(any(), any(), any());
 855         doReturn(null).when(healthCheckInput).getActionIdentifiers();
 856         results = appcProviderLcm.healthCheck(healthCheckInput);
 857         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 858             == results.get().getResult().getStatus().getCode());
 859         verify(appcProviderLcm, times(1)).executeRequest(any());
 860     }
 861
 862     @Test
 863     public void testLiveUpgrade() throws Exception {
 864         // Validation success
 865         doReturn("Success").when(successlcmStatus).getMessage();
 866         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 867         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 868         doReturn(null).when(validationService).validateInput(any(), any(), any());
 869
 870         LiveUpgradeInput liveUpgradeInput = mock(LiveUpgradeInput.class);
 871         doReturn(newCommonHeader("request-id-aduit")).when(liveUpgradeInput).getCommonHeader();
 872         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 873             .when(liveUpgradeInput).getActionIdentifiers();
 874
 875         Future<RpcResult<LiveUpgradeOutput>> results = appcProviderLcm.liveUpgrade(liveUpgradeInput);
 876         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 877         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 878         verify(appcProviderLcm, times(1)).executeRequest(any());
 879
 880         // Validation failed
 881         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 882         results = appcProviderLcm.liveUpgrade(liveUpgradeInput);
 883         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 884         verify(appcProviderLcm, times(1)).executeRequest(any());
 885
 886         // parse exception
 887         doReturn(null).when(validationService).validateInput(any(), any(), any());
 888         doReturn(null).when(liveUpgradeInput).getActionIdentifiers();
 889         results = appcProviderLcm.liveUpgrade(liveUpgradeInput);
 890         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 891             == results.get().getResult().getStatus().getCode());
 892         verify(appcProviderLcm, times(1)).executeRequest(any());
 893     }
 894
 895     @Test
 896     public void testLock() throws Exception {
 897         // Validation success
 898         doReturn("Success").when(successlcmStatus).getMessage();
 899         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 900         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 901         doReturn(null).when(validationService).validateInput(any(), any(), any());
 902
 903         LockInput lockInput = mock(LockInput.class);
 904         doReturn(newCommonHeader("request-id-aduit")).when(lockInput).getCommonHeader();
 905         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 906             .when(lockInput).getActionIdentifiers();
 907
 908         Future<RpcResult<LockOutput>> results = appcProviderLcm.lock(lockInput);
 909         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 910         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 911         verify(appcProviderLcm, times(1)).executeRequest(any());
 912
 913         // Validation failed
 914         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 915         results = appcProviderLcm.lock(lockInput);
 916         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 917         verify(appcProviderLcm, times(1)).executeRequest(any());
 918
 919         // parse exception
 920         doReturn(null).when(validationService).validateInput(any(), any(), any());
 921         doReturn(null).when(lockInput).getActionIdentifiers();
 922         results = appcProviderLcm.lock(lockInput);
 923         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 924             == results.get().getResult().getStatus().getCode());
 925         verify(appcProviderLcm, times(1)).executeRequest(any());
 926     }
 927
 928     @Test
 929     public void testUnlock() throws Exception {
 930         // Validation success
 931         doReturn("Success").when(successlcmStatus).getMessage();
 932         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 933         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 934         doReturn(null).when(validationService).validateInput(any(), any(), any());
 935
 936         UnlockInput unlockInput = mock(UnlockInput.class);
 937         doReturn(newCommonHeader("request-id-aduit")).when(unlockInput).getCommonHeader();
 938         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 939             .when(unlockInput).getActionIdentifiers();
 940
 941         Future<RpcResult<UnlockOutput>> results = appcProviderLcm.unlock(unlockInput);
 942         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 943         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 944         verify(appcProviderLcm, times(1)).executeRequest(any());
 945
 946         // Validation failed
 947         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 948         results = appcProviderLcm.unlock(unlockInput);
 949         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 950         verify(appcProviderLcm, times(1)).executeRequest(any());
 951
 952         // parse exception
 953         doReturn(null).when(validationService).validateInput(any(), any(), any());
 954         doReturn(null).when(unlockInput).getActionIdentifiers();
 955         results = appcProviderLcm.unlock(unlockInput);
 956         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 957             == results.get().getResult().getStatus().getCode());
 958         verify(appcProviderLcm, times(1)).executeRequest(any());
 959     }
 960
 961     @Test
 962     public void testCheckLock() throws Exception {
 963         // Validation success
 964         doReturn("Success").when(successlcmStatus).getMessage();
 965         Map<String, String> additionalContext = new HashMap<>();
 966         additionalContext.put("locked", "true");
 967         doReturn(additionalContext).when(responseContext).getAdditionalContext();
 968         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
 969         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
 970         doReturn(null).when(validationService).validateInput(any(), any(), any());
 971         CheckLockInput checkLockInput = mock(CheckLockInput.class);
 972         doReturn(newCommonHeader("request-id-aduit")).when(checkLockInput).getCommonHeader();
 973         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
 974             .when(checkLockInput).getActionIdentifiers();
 975
 976         Future<RpcResult<CheckLockOutput>> results = appcProviderLcm.checkLock(checkLockInput);
 977         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
 978         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
 979         verify(appcProviderLcm, times(1)).executeRequest(any());
 980
 981         // Validation failed
 982         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
 983         results = appcProviderLcm.checkLock(checkLockInput);
 984         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
 985         verify(appcProviderLcm, times(1)).executeRequest(any());
 986
 987         // parse exception
 988         doReturn(null).when(validationService).validateInput(any(), any(), any());
 989         doReturn(null).when(checkLockInput).getActionIdentifiers();
 990         results = appcProviderLcm.checkLock(checkLockInput);
 991         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
 992             == results.get().getResult().getStatus().getCode());
 993         verify(appcProviderLcm, times(1)).executeRequest(any());
 994     }
 995
 996     @Test
 997     public void testConfigBackup() throws Exception {
 998         // Validation success
 999         doReturn("Success").when(successlcmStatus).getMessage();
1000         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
1001         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
1002         doReturn(null).when(validationService).validateInput(any(), any(), any());
1003
1004         ConfigBackupInput configBackupInput = mock(ConfigBackupInput.class);
1005         doReturn(newCommonHeader("request-id-aduit")).when(configBackupInput).getCommonHeader();
1006         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
1007             .when(configBackupInput).getActionIdentifiers();
1008
1009         Future<RpcResult<ConfigBackupOutput>> results = appcProviderLcm.configBackup(configBackupInput);
1010         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
1011         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
1012         verify(appcProviderLcm, times(1)).executeRequest(any());
1013
1014         // Validation failed
1015         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
1016         results = appcProviderLcm.configBackup(configBackupInput);
1017         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
1018         verify(appcProviderLcm, times(1)).executeRequest(any());
1019
1020         // parse exception
1021         doReturn(null).when(validationService).validateInput(any(), any(), any());
1022         doReturn(null).when(configBackupInput).getActionIdentifiers();
1023         results = appcProviderLcm.configBackup(configBackupInput);
1024         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
1025             == results.get().getResult().getStatus().getCode());
1026         verify(appcProviderLcm, times(1)).executeRequest(any());
1027     }
1028
1029     @Test
1030     public void testConfigBackupDelete() throws Exception {
1031         // Validation success
1032         doReturn("Success").when(successlcmStatus).getMessage();
1033         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
1034         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
1035         doReturn(null).when(validationService).validateInput(any(), any(), any());
1036
1037         ConfigBackupDeleteInput configBackupDeleteInput = mock(ConfigBackupDeleteInput.class);
1038         doReturn(newCommonHeader("request-id-aduit")).when(configBackupDeleteInput).getCommonHeader();
1039         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
1040             .when(configBackupDeleteInput).getActionIdentifiers();
1041
1042         Future<RpcResult<ConfigBackupDeleteOutput>> results = appcProviderLcm.configBackupDelete
1043             (configBackupDeleteInput);
1044         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
1045         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
1046         verify(appcProviderLcm, times(1)).executeRequest(any());
1047
1048         // Validation failed
1049         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
1050         results = appcProviderLcm.configBackupDelete(configBackupDeleteInput);
1051         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
1052         verify(appcProviderLcm, times(1)).executeRequest(any());
1053
1054         // parse exception
1055         doReturn(null).when(validationService).validateInput(any(), any(), any());
1056         doReturn(null).when(configBackupDeleteInput).getActionIdentifiers();
1057         results = appcProviderLcm.configBackupDelete(configBackupDeleteInput);
1058         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
1059             == results.get().getResult().getStatus().getCode());
1060         verify(appcProviderLcm, times(1)).executeRequest(any());
1061     }
1062
1063     @Test
1064     public void testConfigExport() throws Exception {
1065         // Validation success
1066         doReturn("Success").when(successlcmStatus).getMessage();
1067         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
1068         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
1069         doReturn(null).when(validationService).validateInput(any(), any(), any());
1070
1071         ConfigExportInput configExportInput = mock(ConfigExportInput.class);
1072         doReturn(newCommonHeader("request-id-aduit")).when(configExportInput).getCommonHeader();
1073         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
1074             .when(configExportInput).getActionIdentifiers();
1075
1076         Future<RpcResult<ConfigExportOutput>> results = appcProviderLcm.configExport
1077             (configExportInput);
1078         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
1079         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
1080         verify(appcProviderLcm, times(1)).executeRequest(any());
1081
1082         // Validation failed
1083         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
1084         results = appcProviderLcm.configExport(configExportInput);
1085         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
1086         verify(appcProviderLcm, times(1)).executeRequest(any());
1087
1088         // parse exception
1089         doReturn(null).when(validationService).validateInput(any(), any(), any());
1090         doReturn(null).when(configExportInput).getActionIdentifiers();
1091         results = appcProviderLcm.configExport(configExportInput);
1092         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
1093             == results.get().getResult().getStatus().getCode());
1094         verify(appcProviderLcm, times(1)).executeRequest(any());
1095     }
1096
1097     @Test
1098     public void testStopApplication() throws Exception {
1099         // Validation success
1100         doReturn("Success").when(successlcmStatus).getMessage();
1101         doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
1102         doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
1103         doReturn(null).when(validationService).validateInput(any(), any(), any());
1104
1105         StopApplicationInput stopApplicationInput = mock(StopApplicationInput.class);
1106         doReturn(newCommonHeader("request-id-aduit")).when(stopApplicationInput).getCommonHeader();
1107         doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
1108             .when(stopApplicationInput).getActionIdentifiers();
1109
1110         Future<RpcResult<StopApplicationOutput>> results = appcProviderLcm.stopApplication
1111             (stopApplicationInput);
1112         Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
1113         Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
1114         verify(appcProviderLcm, times(1)).executeRequest(any());
1115
1116         // Validation failed
1117         doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
1118         results = appcProviderLcm.stopApplication(stopApplicationInput);
1119         Assert.assertEquals(failStatus, results.get().getResult().getStatus());
1120         verify(appcProviderLcm, times(1)).executeRequest(any());
1121
1122         // parse exception
1123         doReturn(null).when(validationService).validateInput(any(), any(), any());
1124         doReturn(null).when(stopApplicationInput).getActionIdentifiers();
1125         results = appcProviderLcm.stopApplication(stopApplicationInput);
1126         Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
1127             == results.get().getResult().getStatus().getCode());
1128         verify(appcProviderLcm, times(1)).executeRequest(any());
1129     }
1130
1131     @Test
1132     public void testQuery() throws Exception {
1133         QueryInput mockInput = mock(QueryInput.class);
1134         QueryOutput mockOutput = mock(QueryOutput.class);
1135         QueryOutputBuilder mockQueryOutputBuilder = mock(QueryOutputBuilder.class);
1136         QueryService mockQuery = mock(QueryService.class);
1137
1138         whenNew(QueryService.class).withNoArguments().thenReturn(mockQuery);
1139         when(mockQuery.process(mockInput)).thenReturn(mockQueryOutputBuilder);
1140         when(mockQueryOutputBuilder.build()).thenReturn(mockOutput);
1141
1142         Future<RpcResult<QueryOutput>> results = appcProviderLcm.query(mockInput);
1143         verify(mockQuery, times(1)).process(mockInput);
1144         Assert.assertEquals("Should return mockOutput", mockOutput, results.get().getResult());
1145     }
1146
1147     @Test
1148     public void testReboot() throws Exception {
1149         RebootInput mockInput = mock(RebootInput.class);
1150         RebootOutput mockOutput = mock(RebootOutput.class);
1151         RebootOutputBuilder mockRebootOutputBuilder = mock(RebootOutputBuilder.class);
1152         RebootService mockReboot = mock(RebootService.class);
1153
1154         whenNew(RebootService.class).withNoArguments().thenReturn(mockReboot);
1155         when(mockReboot.process(mockInput)).thenReturn(mockRebootOutputBuilder);
1156         when(mockRebootOutputBuilder.build()).thenReturn(mockOutput);
1157
1158         Future<RpcResult<RebootOutput>> results = appcProviderLcm.reboot(mockInput);
1159         verify(mockReboot, times(1)).process(mockInput);
1160         Assert.assertEquals("Should return mockOutput", mockOutput, results.get().getResult());
1161     }
1162
1163     @Test
1164     public void testAttachVolume() throws Exception {
1165         AttachVolumeInput mockInput = mock(AttachVolumeInput.class);
1166         AttachVolumeOutput mockOutput = mock(AttachVolumeOutput.class);
1167         AttachVolumeOutputBuilder mockOutputBuilder = mock(AttachVolumeOutputBuilder.class);
1168         VolumeService mockVolumeService = mock(VolumeService.class);
1169
1170         whenNew(VolumeService.class).withArguments(true).thenReturn(mockVolumeService);
1171         when(mockVolumeService.attachVolume(mockInput)).thenReturn(mockOutputBuilder);
1172         when(mockOutputBuilder.build()).thenReturn(mockOutput);
1173
1174         Future<RpcResult<AttachVolumeOutput>> results = appcProviderLcm.attachVolume(mockInput);
1175         verify(mockVolumeService, times(1)).attachVolume(mockInput);
1176         Assert.assertEquals("Should return mockOutput", mockOutput, results.get().getResult());
1177     }
1178
1179     @Test
1180     public void testDetachVolume() throws Exception {
1181         DetachVolumeInput mockInput = mock(DetachVolumeInput.class);
1182         DetachVolumeOutput mockOutput = mock(DetachVolumeOutput.class);
1183         DetachVolumeOutputBuilder mockOutputBuilder = mock(DetachVolumeOutputBuilder.class);
1184         VolumeService mockVolumeService = mock(VolumeService.class);
1185
1186         whenNew(VolumeService.class).withArguments(false).thenReturn(mockVolumeService);
1187         when(mockVolumeService.detachVolume(mockInput)).thenReturn(mockOutputBuilder);
1188         when(mockOutputBuilder.build()).thenReturn(mockOutput);
1189
1190         Future<RpcResult<DetachVolumeOutput>> results = appcProviderLcm.detachVolume(mockInput);
1191         verify(mockVolumeService, times(1)).detachVolume(mockInput);
1192         Assert.assertEquals("Should return mockOutput", mockOutput, results.get().getResult());
1193     }
1194
1195     @Test
1196     public void testQuiesceTraffic() throws Exception {
1197         QuiesceTrafficInput mockInput = mock(QuiesceTrafficInput.class);
1198         QuiesceTrafficOutput mockOutput = mock(QuiesceTrafficOutput.class);
1199         QuiesceTrafficOutputBuilder mockOutputBuilder = mock(QuiesceTrafficOutputBuilder.class);
1200         QuiesceTrafficService mockService = mock(QuiesceTrafficService.class);
1201
1202         whenNew(QuiesceTrafficService.class).withNoArguments().thenReturn(mockService);
1203         when(mockService.process(mockInput)).thenReturn(mockOutputBuilder);
1204         when(mockOutputBuilder.build()).thenReturn(mockOutput);
1205
1206         Future<RpcResult<QuiesceTrafficOutput>> results = appcProviderLcm.quiesceTraffic(mockInput);
1207         verify(mockService, times(1)).process(mockInput);
1208         Assert.assertEquals("Should return mockOutput", mockOutput, results.get().getResult());
1209     }
1210
1211     @Test
1212     public void testResumeTraffic() throws Exception {
1213         ResumeTrafficInput mockInput = mock(ResumeTrafficInput.class);
1214         ResumeTrafficOutput mockOutput = mock(ResumeTrafficOutput.class);
1215         ResumeTrafficOutputBuilder mockOutputBuilder = mock(ResumeTrafficOutputBuilder.class);
1216         ResumeTrafficService mockService = mock(ResumeTrafficService.class);
1217
1218         whenNew(ResumeTrafficService.class).withNoArguments().thenReturn(mockService);
1219         when(mockService.process(mockInput)).thenReturn(mockOutputBuilder);
1220         when(mockOutputBuilder.build()).thenReturn(mockOutput);
1221
1222         Future<RpcResult<ResumeTrafficOutput>> results = appcProviderLcm.resumeTraffic(mockInput);
1223         verify(mockService, times(1)).process(mockInput);
1224         Assert.assertEquals("Should return mockOutput", mockOutput, results.get().getResult());
1225     }
1226
1227     @Test
1228     public void testUpgradePreCheck() throws Exception {
1229         UpgradePreCheckInput mockInput = mock(UpgradePreCheckInput.class);
1230         UpgradePreCheckOutput mockOutput = mock(UpgradePreCheckOutput.class);
1231         UpgradePreCheckOutputBuilder mockOutputBuilder = mock(UpgradePreCheckOutputBuilder.class);
1232         UpgradeService mockService = mock(UpgradeService.class);
1233
1234         whenNew(UpgradeService.class).withAnyArguments().thenReturn(mockService);
1235         when(mockService.upgradePreCheck(mockInput)).thenReturn(mockOutputBuilder);
1236         when(mockOutputBuilder.build()).thenReturn(mockOutput);
1237
1238         Future<RpcResult<UpgradePreCheckOutput>> results = appcProviderLcm.upgradePreCheck(mockInput);
1239         verify(mockService, times(1)).upgradePreCheck(mockInput);
1240         Assert.assertEquals("Should return mockOutput", mockOutput, results.get().getResult());
1241     }
1242
1243
1244     @Test
1245     public void testUpgradePostCheck() throws Exception {
1246         UpgradePostCheckInput mockInput = mock(UpgradePostCheckInput.class);
1247         UpgradePostCheckOutput mockOutput = mock(UpgradePostCheckOutput.class);
1248         UpgradePostCheckOutputBuilder mockOutputBuilder = mock(UpgradePostCheckOutputBuilder.class);
1249         UpgradeService mockService = mock(UpgradeService.class);
1250
1251         whenNew(UpgradeService.class).withAnyArguments().thenReturn(mockService);
1252         when(mockService.upgradePostCheck(mockInput)).thenReturn(mockOutputBuilder);
1253         when(mockOutputBuilder.build()).thenReturn(mockOutput);
1254
1255         Future<RpcResult<UpgradePostCheckOutput>> results = appcProviderLcm.upgradePostCheck(mockInput);
1256         verify(mockService, times(1)).upgradePostCheck(mockInput);
1257         Assert.assertEquals("Should return mockOutput", mockOutput, results.get().getResult());
1258     }
1259
1260     @Test
1261     public void testUpgradeSoftware() throws Exception {
1262         UpgradeSoftwareInput mockInput = mock(UpgradeSoftwareInput.class);
1263         UpgradeSoftwareOutput mockOutput = mock(UpgradeSoftwareOutput.class);
1264         UpgradeSoftwareOutputBuilder mockOutputBuilder = mock(UpgradeSoftwareOutputBuilder.class);
1265         UpgradeService mockService = mock(UpgradeService.class);
1266
1267         whenNew(UpgradeService.class).withAnyArguments().thenReturn(mockService);
1268         when(mockService.upgradeSoftware(mockInput)).thenReturn(mockOutputBuilder);
1269         when(mockOutputBuilder.build()).thenReturn(mockOutput);
1270
1271         Future<RpcResult<UpgradeSoftwareOutput>> results = appcProviderLcm.upgradeSoftware(mockInput);
1272         verify(mockService, times(1)).upgradeSoftware(mockInput);
1273         Assert.assertEquals("Should return mockOutput", mockOutput, results.get().getResult());
1274     }
1275
1276     @Test
1277     public void testUpgradeBackup() throws Exception {
1278         UpgradeBackupInput mockInput = mock(UpgradeBackupInput.class);
1279         UpgradeBackupOutput mockOutput = mock(UpgradeBackupOutput.class);
1280         UpgradeBackupOutputBuilder mockOutputBuilder = mock(UpgradeBackupOutputBuilder.class);
1281         UpgradeService mockService = mock(UpgradeService.class);
1282
1283         whenNew(UpgradeService.class).withAnyArguments().thenReturn(mockService);
1284         when(mockService.upgradeBackup(mockInput)).thenReturn(mockOutputBuilder);
1285         when(mockOutputBuilder.build()).thenReturn(mockOutput);
1286
1287         Future<RpcResult<UpgradeBackupOutput>> results = appcProviderLcm.upgradeBackup(mockInput);
1288         verify(mockService, times(1)).upgradeBackup(mockInput);
1289         Assert.assertEquals("Should return mockOutput", mockOutput, results.get().getResult());
1290     }
1291
1292     @Test
1293     public void testUpgradeBackout() throws Exception {
1294         UpgradeBackoutInput mockInput = mock(UpgradeBackoutInput.class);
1295         UpgradeBackoutOutput mockOutput = mock(UpgradeBackoutOutput.class);
1296         UpgradeBackoutOutputBuilder mockOutputBuilder = mock(UpgradeBackoutOutputBuilder.class);
1297         UpgradeService mockService = mock(UpgradeService.class);
1298
1299         whenNew(UpgradeService.class).withAnyArguments().thenReturn(mockService);
1300         when(mockService.upgradeBackout(mockInput)).thenReturn(mockOutputBuilder);
1301         when(mockOutputBuilder.build()).thenReturn(mockOutput);
1302
1303         Future<RpcResult<UpgradeBackoutOutput>> results = appcProviderLcm.upgradeBackout(mockInput);
1304         verify(mockService, times(1)).upgradeBackout(mockInput);
1305         Assert.assertEquals("Should return mockOutput", mockOutput, results.get().getResult());
1306     }
1307
1308     @After
1309     public void tearDown() throws Exception {
1310         if (appcProviderLcm != null) {
1311             appcProviderLcm.close();
1312         }
1313     }
1314
1315
1316     private ActionIdentifiers newActionIdentifier(String vnfId, String vnfcId, String vserverId) {
1317         ActionIdentifiersBuilder actionIdentifiersBuilder = new ActionIdentifiersBuilder();
1318         actionIdentifiersBuilder.setVnfId(vnfId);
1319         actionIdentifiersBuilder.setVnfcName(vnfcId);
1320         actionIdentifiersBuilder.setVserverId(vserverId);
1321         return actionIdentifiersBuilder.build();
1322     }
1323
1324     private CommonHeader newCommonHeader(String requestId) {
1325         CommonHeaderBuilder commonHeaderBuilder = new CommonHeaderBuilder();
1326         commonHeaderBuilder.setRequestId(requestId);
1327         commonHeaderBuilder.setApiVer("2.0.0");
1328         commonHeaderBuilder.setOriginatorId("originatortest");
1329         commonHeaderBuilder.setTimestamp(ZULU.getDefaultInstance(LocalDateTime.now(Clock.systemUTC()).toString() +
1330             "Z"));
1331         return commonHeaderBuilder.build();
1332     }
1333 }