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