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