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