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