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