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) 2018-2019 Ericsson
   6  * ================================================================================
   7  * Modifications Copyright (C) 2019 Orange
   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 static org.junit.Assert.assertTrue;
  27 import static org.mockito.Mockito.mock;
  28 import java.util.HashMap;
  29 import java.util.Map;
  30 import org.junit.Before;
  31 import org.junit.Test;
  32 import org.mockito.Mockito;
  33 import org.onap.appc.domainmodel.lcm.ResponseContext;
  34 import org.onap.appc.domainmodel.lcm.Status;
  35 import org.onap.appc.requesthandler.objects.RequestHandlerInput;
  36 import org.onap.appc.requesthandler.objects.RequestHandlerOutput;
  37 import org.opendaylight.mdsal.binding.api.DataBroker;
  38 import org.opendaylight.mdsal.binding.api.NotificationPublishService;
  39 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
  40 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RpcRegistration;
  41 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
  42 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.Action;
  43 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ActionStatusInput;
  44 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AppcProviderLcmService;
  45 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AttachVolumeInput;
  46 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AuditInput;
  47 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.CheckLockInput;
  48 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigBackupDeleteInput;
  49 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigBackupInput;
  50 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigExportInput;
  51 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigModifyInput;
  52 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigRestoreInput;
  53 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigScaleOutInput;
  54 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigureInput;
  55 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.DetachVolumeInput;
  56 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.DistributeTrafficInput;
  57 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.DistributeTrafficCheckInput;
  58 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.EvacuateInput;
  59 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.HealthCheckInput;
  60 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.LiveUpgradeInput;
  61 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.LockInput;
  62 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.MigrateInput;
  63 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.QueryInput;
  64 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.QuiesceTrafficInput;
  65 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RebootInput;
  66 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RebuildInput;
  67 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RestartInput;
  68 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ResumeTrafficInput;
  69 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RollbackInput;
  70 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SnapshotInput;
  71 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SoftwareUploadInput;
  72 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StartApplicationInput;
  73 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StartInput;
  74 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StopApplicationInput;
  75 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StopInput;
  76 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SyncInput;
  77 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.TerminateInput;
  78 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.TestInput;
  79 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UnlockInput;
  80 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeBackoutInput;
  81 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeBackupInput;
  82 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradePostCheckInput;
  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.UpgradeSoftwareInput;
  85 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ZULU;
  86 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.action.identifiers.ActionIdentifiersBuilder;
  87 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.common.header.CommonHeaderBuilder;
  88
  89
  90 public class AppcProviderLcmTest {
  91
  92     private interface ParameterizedRpcRegistration extends RpcRegistration<AppcProviderLcmService> {}
  93     private DataBroker dataBroker;
  94     private NotificationPublishService notificationProviderService;
  95     private RpcProviderRegistry rpcProviderRegistry;
  96     private BindingAwareBroker.RpcRegistration<AppcProviderLcmService> rpcRegistration;
  97     private AppcProviderLcm underTest;
  98     private RequestHandlerOutput output;
  99
 100     @Before
 101     public void setupMocksForTests() {
 102         dataBroker = mock(DataBroker.class);
 103         notificationProviderService = mock(NotificationPublishService.class);
 104         rpcProviderRegistry = mock(RpcProviderRegistry.class);
 105         rpcRegistration = mock(ParameterizedRpcRegistration.class);
 106         Mockito.doReturn(rpcRegistration).when(rpcProviderRegistry).addRpcImplementation(
 107                 Mockito.any(Class.class), Mockito.any(AppcProviderLcm.class));
 108         underTest =
 109                 new AppcProviderLcm(dataBroker, notificationProviderService, rpcProviderRegistry);
 110         output = Mockito.mock(RequestHandlerOutput.class);
 111         ResponseContext responseContext = Mockito.mock(ResponseContext.class);
 112         Status status = Mockito.mock(Status.class);
 113         Mockito.doReturn(200).when(status).getCode();
 114         Mockito.doReturn(status).when(responseContext).getStatus();
 115         Mockito.doReturn(responseContext).when(output).getResponseContext();
 116     }
 117
 118     @Test
 119     public void rebuildTestParseException() {
 120         RebuildInput rebuildInput = mock(RebuildInput.class);
 121         Mockito.doReturn(Action.Rebuild).when(rebuildInput).getAction();
 122         Mockito.doReturn(getCommonHeaderBuilder().build()).when(rebuildInput).getCommonHeader();
 123         assertTrue(underTest.rebuild(rebuildInput).isDone());
 124     }
 125
 126     @Test
 127     public void rebuildTest() {
 128         AppcProviderLcm underTestSpy = Mockito.spy(underTest);
 129         RebuildInput rebuildInput = mock(RebuildInput.class);
 130         Mockito.doReturn(Action.Rebuild).when(rebuildInput).getAction();
 131         Mockito.doReturn(getCommonHeaderBuilder().build()).when(rebuildInput).getCommonHeader();
 132         Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(rebuildInput).getActionIdentifiers();
 133         Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
 134         assertTrue(underTestSpy.rebuild(rebuildInput).isDone());
 135     }
 136
 137     @Test
 138     public void restartTestParseException() {
 139         RestartInput restartInput = mock(RestartInput.class);
 140         Mockito.doReturn(Action.Restart).when(restartInput).getAction();
 141         Mockito.doReturn(getCommonHeaderBuilder().build()).when(restartInput).getCommonHeader();
 142         assertTrue(underTest.restart(restartInput).isDone());
 143     }
 144
 145     @Test
 146     public void restartTest() {
 147         AppcProviderLcm underTestSpy = Mockito.spy(underTest);
 148         RestartInput restartInput = mock(RestartInput.class);
 149         Mockito.doReturn(Action.Restart).when(restartInput).getAction();
 150         Mockito.doReturn(getCommonHeaderBuilder().build()).when(restartInput).getCommonHeader();
 151         Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(restartInput).getActionIdentifiers();
 152         Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
 153         assertTrue(underTestSpy.restart(restartInput).isDone());
 154     }
 155
 156     @Test
 157     public void startApplicationTestParseException() {
 158         StartApplicationInput startApplicationInput = mock(StartApplicationInput.class);
 159         Mockito.doReturn(Action.StartApplication).when(startApplicationInput).getAction();
 160         Mockito.doReturn(getCommonHeaderBuilder().build()).when(startApplicationInput)
 161                 .getCommonHeader();
 162         assertTrue(underTest.startApplication(startApplicationInput).isDone());
 163     }
 164
 165     @Test
 166     public void startApplicationTest() {
 167         AppcProviderLcm underTestSpy = Mockito.spy(underTest);
 168         StartApplicationInput startApplicationInput = mock(StartApplicationInput.class);
 169         Mockito.doReturn(Action.StartApplication).when(startApplicationInput).getAction();
 170         Mockito.doReturn(getCommonHeaderBuilder().build()).when(startApplicationInput).getCommonHeader();
 171         Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(startApplicationInput).getActionIdentifiers();
 172         Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
 173         assertTrue(underTestSpy.startApplication(startApplicationInput).isDone());
 174     }
 175
 176     @Test
 177     public void migrateTestParseException() {
 178         MigrateInput migrateInput = mock(MigrateInput.class);
 179         Mockito.doReturn(Action.Migrate).when(migrateInput).getAction();
 180         Mockito.doReturn(getCommonHeaderBuilder().build()).when(migrateInput).getCommonHeader();
 181         assertTrue(underTest.migrate(migrateInput).isDone());
 182     }
 183
 184     @Test
 185     public void migrateTest() {
 186         AppcProviderLcm underTestSpy = Mockito.spy(underTest);
 187         MigrateInput migrateInput = mock(MigrateInput.class);
 188         Mockito.doReturn(Action.Migrate).when(migrateInput).getAction();
 189         Mockito.doReturn(getCommonHeaderBuilder().build()).when(migrateInput).getCommonHeader();
 190         Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(migrateInput).getActionIdentifiers();
 191         Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
 192         assertTrue(underTestSpy.migrate(migrateInput).isDone());
 193     }
 194
 195     @Test
 196     public void evacuateTestParseException() {
 197         EvacuateInput evacuateInput = mock(EvacuateInput.class);
 198         Mockito.doReturn(Action.Evacuate).when(evacuateInput).getAction();
 199         Mockito.doReturn(getCommonHeaderBuilder().build()).when(evacuateInput).getCommonHeader();
 200         assertTrue(underTest.evacuate(evacuateInput).isDone());
 201     }
 202
 203     @Test
 204     public void evacuateTest() {
 205         AppcProviderLcm underTestSpy = Mockito.spy(underTest);
 206         EvacuateInput evacuateInput = mock(EvacuateInput.class);
 207         Mockito.doReturn(Action.Evacuate).when(evacuateInput).getAction();
 208         Mockito.doReturn(getCommonHeaderBuilder().build()).when(evacuateInput).getCommonHeader();
 209         Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(evacuateInput).getActionIdentifiers();
 210         Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
 211         assertTrue(underTestSpy.evacuate(evacuateInput).isDone());
 212     }
 213
 214     @Test
 215     public void snapshotTestParseException() {
 216         SnapshotInput snapshotInput = mock(SnapshotInput.class);
 217         Mockito.doReturn(Action.Snapshot).when(snapshotInput).getAction();
 218         Mockito.doReturn(getCommonHeaderBuilder().build()).when(snapshotInput).getCommonHeader();
 219         assertTrue(underTest.snapshot(snapshotInput).isDone());
 220     }
 221
 222     @Test
 223     public void snapshotTest() {
 224         AppcProviderLcm underTestSpy = Mockito.spy(underTest);
 225         SnapshotInput snapshotInput = mock(SnapshotInput.class);
 226         Mockito.doReturn(Action.Snapshot).when(snapshotInput).getAction();
 227         Mockito.doReturn(getCommonHeaderBuilder().build()).when(snapshotInput).getCommonHeader();
 228         Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(snapshotInput).getActionIdentifiers();
 229         Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
 230         assertTrue(underTestSpy.snapshot(snapshotInput).isDone());
 231     }
 232
 233     @Test
 234     public void rollbackTestParseException() {
 235         RollbackInput rollbackInput = mock(RollbackInput.class);
 236         Mockito.doReturn(Action.Rollback).when(rollbackInput).getAction();
 237         Mockito.doReturn(getCommonHeaderBuilder().build()).when(rollbackInput).getCommonHeader();
 238         assertTrue(underTest.rollback(rollbackInput).isDone());
 239     }
 240
 241     @Test
 242     public void rollbackTest() {
 243         AppcProviderLcm underTestSpy = Mockito.spy(underTest);
 244         RollbackInput rollbackInput = mock(RollbackInput.class);
 245         Mockito.doReturn(Action.Rollback).when(rollbackInput).getAction();
 246         Mockito.doReturn(getCommonHeaderBuilder().build()).when(rollbackInput).getCommonHeader();
 247         Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(rollbackInput).getActionIdentifiers();
 248         Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
 249         assertTrue(underTestSpy.rollback(rollbackInput).isDone());
 250     }
 251
 252     @Test
 253     public void syncTestParseException() {
 254         SyncInput syncInput = mock(SyncInput.class);
 255         Mockito.doReturn(Action.Sync).when(syncInput).getAction();
 256         Mockito.doReturn(getCommonHeaderBuilder().build()).when(syncInput).getCommonHeader();
 257         assertTrue(underTest.sync(syncInput).isDone());
 258     }
 259
 260     @Test
 261     public void syncTest() {
 262         AppcProviderLcm underTestSpy = Mockito.spy(underTest);
 263         SyncInput syncInput = mock(SyncInput.class);
 264         Mockito.doReturn(Action.Sync).when(syncInput).getAction();
 265         Mockito.doReturn(getCommonHeaderBuilder().build()).when(syncInput).getCommonHeader();
 266         Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(syncInput).getActionIdentifiers();
 267         Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
 268         assertTrue(underTestSpy.sync(syncInput).isDone());
 269     }
 270
 271     @Test
 272     public void queryTest() {
 273         QueryInput queryInput = mock(QueryInput.class);
 274         Mockito.doReturn(Action.Query).when(queryInput).getAction();
 275         assertTrue(underTest.query(queryInput).isDone());
 276     }
 277
 278     @Test
 279     public void attachVolumeTest() {
 280         AttachVolumeInput attachVolumeInput = mock(AttachVolumeInput.class);
 281         Mockito.doReturn(Action.AttachVolume).when(attachVolumeInput).getAction();
 282         assertTrue(underTest.attachVolume(attachVolumeInput).isDone());
 283     }
 284
 285     @Test
 286     public void rebootTest() {
 287         RebootInput rebootInput = mock(RebootInput.class);
 288         Mockito.doReturn(Action.Reboot).when(rebootInput).getAction();
 289         assertTrue(underTest.reboot(rebootInput).isDone());
 290     }
 291
 292     @Test
 293     public void detachVolumeTest() {
 294         DetachVolumeInput detachVolumeInput = mock(DetachVolumeInput.class);
 295         Mockito.doReturn(Action.DetachVolume).when(detachVolumeInput).getAction();
 296         assertTrue(underTest.detachVolume(detachVolumeInput).isDone());
 297     }
 298
 299     @Test
 300     public void quiesceTrafficTest() {
 301         QuiesceTrafficInput quiesceTrafficInput = mock(QuiesceTrafficInput.class);
 302         Mockito.doReturn(Action.QuiesceTraffic).when(quiesceTrafficInput).getAction();
 303         assertTrue(underTest.quiesceTraffic(quiesceTrafficInput).isDone());
 304     }
 305
 306     @Test
 307     public void resumeTrafficTest() {
 308         ResumeTrafficInput resumeTrafficInput = mock(ResumeTrafficInput.class);
 309         Mockito.doReturn(Action.ResumeTraffic).when(resumeTrafficInput).getAction();
 310         assertTrue(underTest.resumeTraffic(resumeTrafficInput).isDone());
 311     }
 312
 313     @Test
 314     public void distributeTrafficTest() {
 315         DistributeTrafficInput distributeTrafficInput = mock(DistributeTrafficInput.class);
 316         Mockito.doReturn(Action.DistributeTraffic).when(distributeTrafficInput).getAction();
 317         assertTrue(underTest.distributeTraffic(distributeTrafficInput).isDone());
 318     }
 319
 320     @Test
 321     public void distributeTrafficCheckTest() {
 322         DistributeTrafficCheckInput distributeTrafficCheckInput = mock(DistributeTrafficCheckInput.class);
 323         Mockito.doReturn(Action.DistributeTrafficCheck).when(distributeTrafficCheckInput).getAction();
 324         assertTrue(underTest.distributeTrafficCheck(distributeTrafficCheckInput).isDone());
 325     }
 326
 327     @Test
 328     public void upgradePreCheckInputTest() {
 329         UpgradePreCheckInput upgradePreCheckInput = mock(UpgradePreCheckInput.class);
 330         Mockito.doReturn(Action.UpgradePreCheck).when(upgradePreCheckInput).getAction();
 331         assertTrue(underTest.upgradePreCheck(upgradePreCheckInput).isDone());
 332     }
 333
 334     @Test
 335     public void upgradeSoftwareTest() {
 336         UpgradeSoftwareInput upgradeSoftwareInput = mock(UpgradeSoftwareInput.class);
 337         Mockito.doReturn(Action.UpgradeSoftware).when(upgradeSoftwareInput).getAction();
 338         assertTrue(underTest.upgradeSoftware(upgradeSoftwareInput).isDone());
 339     }
 340
 341     @Test
 342     public void upgradePostCheckTest() {
 343         UpgradePostCheckInput upgradePostCheckInput = mock(UpgradePostCheckInput.class);
 344         Mockito.doReturn(Action.UpgradePostCheck).when(upgradePostCheckInput).getAction();
 345         assertTrue(underTest.upgradePostCheck(upgradePostCheckInput).isDone());
 346     }
 347
 348     @Test
 349     public void upgradeBackupTest() {
 350         UpgradeBackupInput upgradeBackupInput = mock(UpgradeBackupInput.class);
 351         Mockito.doReturn(Action.UpgradeBackup).when(upgradeBackupInput).getAction();
 352         assertTrue(underTest.upgradeBackup(upgradeBackupInput).isDone());
 353     }
 354
 355     @Test
 356     public void upgradeBackoutTest() {
 357         UpgradeBackoutInput upgradeBackoutInput = mock(UpgradeBackoutInput.class);
 358         Mockito.doReturn(Action.UpgradeBackout).when(upgradeBackoutInput).getAction();
 359         assertTrue(underTest.upgradeBackout(upgradeBackoutInput).isDone());
 360     }
 361
 362     @Test
 363     public void terminateTestParseException() {
 364         TerminateInput terminateInput = mock(TerminateInput.class);
 365         Mockito.doReturn(Action.Terminate).when(terminateInput).getAction();
 366         Mockito.doReturn(getCommonHeaderBuilder().build()).when(terminateInput).getCommonHeader();
 367         assertTrue(underTest.terminate(terminateInput).isDone());
 368     }
 369
 370     @Test
 371     public void terminateTest() {
 372         AppcProviderLcm underTestSpy = Mockito.spy(underTest);
 373         TerminateInput terminateInput = mock(TerminateInput.class);
 374         Mockito.doReturn(Action.Terminate).when(terminateInput).getAction();
 375         Mockito.doReturn(getCommonHeaderBuilder().build()).when(terminateInput).getCommonHeader();
 376         Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(terminateInput).getActionIdentifiers();
 377         Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
 378         assertTrue(underTestSpy.terminate(terminateInput).isDone());
 379     }
 380
 381     @Test
 382     public void configScaleOutTest() {
 383         ConfigScaleOutInput configScaleOutInput = mock(ConfigScaleOutInput.class);
 384         Mockito.doReturn(Action.ConfigScaleOut).when(configScaleOutInput).getAction();
 385         Mockito.doReturn(getCommonHeaderBuilder().build()).when(configScaleOutInput)
 386                 .getCommonHeader();
 387         assertTrue(underTest.configScaleOut(configScaleOutInput).isDone());
 388     }
 389
 390     @Test
 391     public void configModifyTestParseException() {
 392         ConfigModifyInput configModifyInput = mock(ConfigModifyInput.class);
 393         Mockito.doReturn(Action.ConfigModify).when(configModifyInput).getAction();
 394         Mockito.doReturn(getCommonHeaderBuilder().build()).when(configModifyInput)
 395                 .getCommonHeader();
 396         assertTrue(underTest.configModify(configModifyInput).isDone());
 397     }
 398
 399     @Test
 400     public void configModifyTest() {
 401         AppcProviderLcm underTestSpy = Mockito.spy(underTest);
 402         ConfigModifyInput configModifyInput = mock(ConfigModifyInput.class);
 403         Mockito.doReturn(Action.ConfigModify).when(configModifyInput).getAction();
 404         Mockito.doReturn(getCommonHeaderBuilder().build()).when(configModifyInput).getCommonHeader();
 405         Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(configModifyInput).getActionIdentifiers();
 406         Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
 407         assertTrue(underTestSpy.configModify(configModifyInput).isDone());
 408     }
 409
 410     @Test
 411     public void actionStatusTest() {
 412         ActionStatusInput actionStatusInput = mock(ActionStatusInput.class);
 413         Mockito.doReturn(Action.ActionStatus).when(actionStatusInput).getAction();
 414         assertTrue(underTest.actionStatus(actionStatusInput).isDone());
 415     }
 416
 417     @Test
 418     public void configRestoreTestParseException() {
 419         ConfigRestoreInput configRestoreInput = mock(ConfigRestoreInput.class);
 420         Mockito.doReturn(Action.ConfigRestore).when(configRestoreInput).getAction();
 421         Mockito.doReturn(getCommonHeaderBuilder().build()).when(configRestoreInput)
 422                 .getCommonHeader();
 423         assertTrue(underTest.configRestore(configRestoreInput).isDone());
 424     }
 425
 426     @Test
 427     public void configRestoreTest() {
 428         AppcProviderLcm underTestSpy = Mockito.spy(underTest);
 429         ConfigRestoreInput configRestoreInput = mock(ConfigRestoreInput.class);
 430         Mockito.doReturn(Action.ConfigRestore).when(configRestoreInput).getAction();
 431         Mockito.doReturn(getCommonHeaderBuilder().build()).when(configRestoreInput).getCommonHeader();
 432         Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(configRestoreInput).getActionIdentifiers();
 433         Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
 434         assertTrue(underTestSpy.configRestore(configRestoreInput).isDone());
 435     }
 436
 437     @Test
 438     public void configureTestParseException() {
 439         ConfigureInput configureInput = mock(ConfigureInput.class);
 440         Mockito.doReturn(Action.Configure).when(configureInput).getAction();
 441         Mockito.doReturn(getCommonHeaderBuilder().build()).when(configureInput).getCommonHeader();
 442         assertTrue(underTest.configure(configureInput).isDone());
 443     }
 444
 445     @Test
 446     public void configureTest() {
 447         AppcProviderLcm underTestSpy = Mockito.spy(underTest);
 448         ConfigureInput configureInput = mock(ConfigureInput.class);
 449         Mockito.doReturn(Action.Configure).when(configureInput).getAction();
 450         Mockito.doReturn(getCommonHeaderBuilder().build()).when(configureInput).getCommonHeader();
 451         Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(configureInput).getActionIdentifiers();
 452         Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
 453         assertTrue(underTestSpy.configure(configureInput).isDone());
 454     }
 455
 456     @Test
 457     public void testTestParseException() {
 458         TestInput testInput = mock(TestInput.class);
 459         Mockito.doReturn(Action.Test).when(testInput).getAction();
 460         Mockito.doReturn(getCommonHeaderBuilder().build()).when(testInput).getCommonHeader();
 461         assertTrue(underTest.test(testInput).isDone());
 462     }
 463
 464     @Test
 465     public void testTest() {
 466         AppcProviderLcm underTestSpy = Mockito.spy(underTest);
 467         TestInput testInput = mock(TestInput.class);
 468         Mockito.doReturn(Action.Test).when(testInput).getAction();
 469         Mockito.doReturn(getCommonHeaderBuilder().build()).when(testInput).getCommonHeader();
 470         Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(testInput).getActionIdentifiers();
 471         Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
 472         assertTrue(underTestSpy.test(testInput).isDone());
 473     }
 474
 475     @Test
 476     public void stopTestParseException() {
 477         StopInput stopInput = mock(StopInput.class);
 478         Mockito.doReturn(Action.Stop).when(stopInput).getAction();
 479         Mockito.doReturn(getCommonHeaderBuilder().build()).when(stopInput).getCommonHeader();
 480         assertTrue(underTest.stop(stopInput).isDone());
 481     }
 482
 483     @Test
 484     public void stopTest() {
 485         AppcProviderLcm underTestSpy = Mockito.spy(underTest);
 486         StopInput stopInput = mock(StopInput.class);
 487         Mockito.doReturn(Action.Stop).when(stopInput).getAction();
 488         Mockito.doReturn(getCommonHeaderBuilder().build()).when(stopInput).getCommonHeader();
 489         Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(stopInput).getActionIdentifiers();
 490         Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
 491         assertTrue(underTestSpy.stop(stopInput).isDone());
 492     }
 493
 494     @Test
 495     public void startTestParseException() {
 496         StartInput startInput = mock(StartInput.class);
 497         Mockito.doReturn(Action.Start).when(startInput).getAction();
 498         Mockito.doReturn(getCommonHeaderBuilder().build()).when(startInput).getCommonHeader();
 499         assertTrue(underTest.start(startInput).isDone());
 500     }
 501
 502     @Test
 503     public void startTest() {
 504         AppcProviderLcm underTestSpy = Mockito.spy(underTest);
 505         StartInput startInput = mock(StartInput.class);
 506         Mockito.doReturn(Action.Rebuild).when(startInput).getAction();
 507         Mockito.doReturn(getCommonHeaderBuilder().build()).when(startInput).getCommonHeader();
 508         Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(startInput).getActionIdentifiers();
 509         Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
 510         assertTrue(underTestSpy.start(startInput).isDone());
 511     }
 512
 513     @Test
 514     public void auditTestParseExcpetion() {
 515         AuditInput auditInput = mock(AuditInput.class);
 516         Mockito.doReturn(Action.Audit).when(auditInput).getAction();
 517         Mockito.doReturn(getCommonHeaderBuilder().build()).when(auditInput).getCommonHeader();
 518         assertTrue(underTest.audit(auditInput).isDone());
 519     }
 520
 521     @Test
 522     public void auditTest() {
 523         AppcProviderLcm underTestSpy = Mockito.spy(underTest);
 524         AuditInput auditInput = mock(AuditInput.class);
 525         Mockito.doReturn(Action.Audit).when(auditInput).getAction();
 526         Mockito.doReturn(getCommonHeaderBuilder().build()).when(auditInput).getCommonHeader();
 527         Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(auditInput).getActionIdentifiers();
 528         Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
 529         assertTrue(underTestSpy.audit(auditInput).isDone());
 530     }
 531
 532     @Test
 533     public void softwareUploadTestParseException() {
 534         SoftwareUploadInput softwareUploadInput = mock(SoftwareUploadInput.class);
 535         Mockito.doReturn(Action.SoftwareUpload).when(softwareUploadInput).getAction();
 536         Mockito.doReturn(getCommonHeaderBuilder().build()).when(softwareUploadInput)
 537                 .getCommonHeader();
 538         assertTrue(underTest.softwareUpload(softwareUploadInput).isDone());
 539     }
 540
 541     @Test
 542     public void softwareUploadTest() {
 543         AppcProviderLcm underTestSpy = Mockito.spy(underTest);
 544         SoftwareUploadInput softwareUploadInput = mock(SoftwareUploadInput.class);
 545         Mockito.doReturn(Action.SoftwareUpload).when(softwareUploadInput).getAction();
 546         Mockito.doReturn(getCommonHeaderBuilder().build()).when(softwareUploadInput).getCommonHeader();
 547         Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(softwareUploadInput).getActionIdentifiers();
 548         Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
 549         assertTrue(underTestSpy.softwareUpload(softwareUploadInput).isDone());
 550     }
 551
 552     @Test
 553     public void healthCheckTestParseException() {
 554         HealthCheckInput healthCheckInput = mock(HealthCheckInput.class);
 555         Mockito.doReturn(Action.HealthCheck).when(healthCheckInput).getAction();
 556         Mockito.doReturn(getCommonHeaderBuilder().build()).when(healthCheckInput).getCommonHeader();
 557         assertTrue(underTest.healthCheck(healthCheckInput).isDone());
 558     }
 559
 560     @Test
 561     public void healthCheckTest() {
 562         AppcProviderLcm underTestSpy = Mockito.spy(underTest);
 563         HealthCheckInput healthCheckInput = mock(HealthCheckInput.class);
 564         Mockito.doReturn(Action.HealthCheck).when(healthCheckInput).getAction();
 565         Mockito.doReturn(getCommonHeaderBuilder().build()).when(healthCheckInput).getCommonHeader();
 566         Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(healthCheckInput).getActionIdentifiers();
 567         Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
 568         assertTrue(underTestSpy.healthCheck(healthCheckInput).isDone());
 569     }
 570
 571     @Test
 572     public void liveUpgradeTestParseException() {
 573         LiveUpgradeInput liveUpgradeInput = mock(LiveUpgradeInput.class);
 574         Mockito.doReturn(Action.LiveUpgrade).when(liveUpgradeInput).getAction();
 575         Mockito.doReturn(getCommonHeaderBuilder().build()).when(liveUpgradeInput).getCommonHeader();
 576         assertTrue(underTest.liveUpgrade(liveUpgradeInput).isDone());
 577     }
 578
 579     @Test
 580     public void liveUpgradeTest() {
 581         AppcProviderLcm underTestSpy = Mockito.spy(underTest);
 582         LiveUpgradeInput liveUpgradeInput = mock(LiveUpgradeInput.class);
 583         Mockito.doReturn(Action.LiveUpgrade).when(liveUpgradeInput).getAction();
 584         Mockito.doReturn(getCommonHeaderBuilder().build()).when(liveUpgradeInput).getCommonHeader();
 585         Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(liveUpgradeInput).getActionIdentifiers();
 586         Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
 587         assertTrue(underTestSpy.liveUpgrade(liveUpgradeInput).isDone());
 588     }
 589
 590     @Test
 591     public void lockTestParseException() {
 592         LockInput lockInput = mock(LockInput.class);
 593         Mockito.doReturn(Action.Lock).when(lockInput).getAction();
 594         Mockito.doReturn(getCommonHeaderBuilder().build()).when(lockInput).getCommonHeader();
 595         assertTrue(underTest.lock(lockInput).isDone());
 596     }
 597
 598     @Test
 599     public void lockTest() {
 600         AppcProviderLcm underTestSpy = Mockito.spy(underTest);
 601         LockInput lockInput = mock(LockInput.class);
 602         Mockito.doReturn(Action.LiveUpgrade).when(lockInput).getAction();
 603         Mockito.doReturn(getCommonHeaderBuilder().build()).when(lockInput).getCommonHeader();
 604         Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(lockInput).getActionIdentifiers();
 605         Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
 606         assertTrue(underTestSpy.lock(lockInput).isDone());
 607     }
 608
 609     @Test
 610     public void unlockTestParseException() {
 611         UnlockInput unlockInput = mock(UnlockInput.class);
 612         Mockito.doReturn(Action.Unlock).when(unlockInput).getAction();
 613         Mockito.doReturn(getCommonHeaderBuilder().build()).when(unlockInput).getCommonHeader();
 614         assertTrue(underTest.unlock(unlockInput).isDone());
 615     }
 616
 617     @Test
 618     public void unLockTest() {
 619         AppcProviderLcm underTestSpy = Mockito.spy(underTest);
 620         UnlockInput unlockInput = mock(UnlockInput.class);
 621         Mockito.doReturn(Action.Unlock).when(unlockInput).getAction();
 622         Mockito.doReturn(getCommonHeaderBuilder().build()).when(unlockInput).getCommonHeader();
 623         Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(unlockInput).getActionIdentifiers();
 624         Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
 625         assertTrue(underTestSpy.unlock(unlockInput).isDone());
 626     }
 627
 628     @Test
 629     public void checkLockTestParseException() {
 630         CheckLockInput checkLockInput = mock(CheckLockInput.class);
 631         Mockito.doReturn(Action.CheckLock).when(checkLockInput).getAction();
 632         Mockito.doReturn(getCommonHeaderBuilder().build()).when(checkLockInput).getCommonHeader();
 633         assertTrue(underTest.checkLock(checkLockInput).isDone());
 634     }
 635
 636     @Test
 637     public void checkLockTest() {
 638         AppcProviderLcm underTestSpy = Mockito.spy(underTest);
 639         CheckLockInput checkLockInput = mock(CheckLockInput.class);
 640         Mockito.doReturn(Action.CheckLock).when(checkLockInput).getAction();
 641         Mockito.doReturn(getCommonHeaderBuilder().build()).when(checkLockInput).getCommonHeader();
 642         Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(checkLockInput).getActionIdentifiers();
 643         RequestHandlerOutput output = Mockito.mock(RequestHandlerOutput.class);
 644         ResponseContext responseContext = Mockito.mock(ResponseContext.class);
 645         Status status = Mockito.mock(Status.class);
 646         Map<String, String> additionalContext = new HashMap<>();
 647         additionalContext.put("locked", "true");
 648         Mockito.doReturn(additionalContext).when(responseContext).getAdditionalContext();
 649         Mockito.doReturn(400).when(status).getCode();
 650         Mockito.doReturn(status).when(responseContext).getStatus();
 651         Mockito.doReturn(responseContext).when(output).getResponseContext();
 652         Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
 653         assertTrue(underTestSpy.checkLock(checkLockInput).isDone());
 654     }
 655
 656     @Test
 657     public void configBackupTestParseException() {
 658         ConfigBackupInput configBackupInput = mock(ConfigBackupInput.class);
 659         Mockito.doReturn(Action.ConfigBackup).when(configBackupInput).getAction();
 660         Mockito.doReturn(getCommonHeaderBuilder().build()).when(configBackupInput)
 661                 .getCommonHeader();
 662         assertTrue(underTest.configBackup(configBackupInput).isDone());
 663     }
 664
 665     @Test
 666     public void configBackupTest() {
 667         AppcProviderLcm underTestSpy = Mockito.spy(underTest);
 668         ConfigBackupInput configBackupInput = mock(ConfigBackupInput.class);
 669         Mockito.doReturn(Action.ConfigBackup).when(configBackupInput).getAction();
 670         Mockito.doReturn(getCommonHeaderBuilder().build()).when(configBackupInput).getCommonHeader();
 671         Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(configBackupInput).getActionIdentifiers();
 672         Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
 673         assertTrue(underTestSpy.configBackup(configBackupInput).isDone());
 674     }
 675
 676     @Test
 677     public void configBackupDeleteTestParseException() {
 678         ConfigBackupDeleteInput configBackupDeleteInput = mock(ConfigBackupDeleteInput.class);
 679         Mockito.doReturn(Action.ConfigBackupDelete).when(configBackupDeleteInput).getAction();
 680         Mockito.doReturn(getCommonHeaderBuilder().build()).when(configBackupDeleteInput)
 681                 .getCommonHeader();
 682         assertTrue(underTest.configBackupDelete(configBackupDeleteInput).isDone());
 683     }
 684
 685     @Test
 686     public void configBackupDeleteTest() {
 687         AppcProviderLcm underTestSpy = Mockito.spy(underTest);
 688         ConfigBackupDeleteInput configBackupDeleteInput = mock(ConfigBackupDeleteInput.class);
 689         Mockito.doReturn(Action.ConfigBackupDelete).when(configBackupDeleteInput).getAction();
 690         Mockito.doReturn(getCommonHeaderBuilder().build()).when(configBackupDeleteInput).getCommonHeader();
 691         Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(configBackupDeleteInput).getActionIdentifiers();
 692         Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
 693         assertTrue(underTestSpy.configBackupDelete(configBackupDeleteInput).isDone());
 694     }
 695
 696     @Test
 697     public void configExportTestParseException() {
 698         ConfigExportInput configExportInput = mock(ConfigExportInput.class);
 699         Mockito.doReturn(Action.ConfigExport).when(configExportInput).getAction();
 700         Mockito.doReturn(getCommonHeaderBuilder().build()).when(configExportInput)
 701                 .getCommonHeader();
 702         assertTrue(underTest.configExport(configExportInput).isDone());
 703     }
 704
 705     @Test
 706     public void configExportTest() {
 707         AppcProviderLcm underTestSpy = Mockito.spy(underTest);
 708         ConfigExportInput configExportInput = mock(ConfigExportInput.class);
 709         Mockito.doReturn(Action.ConfigExport).when(configExportInput).getAction();
 710         Mockito.doReturn(getCommonHeaderBuilder().build()).when(configExportInput).getCommonHeader();
 711         Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(configExportInput).getActionIdentifiers();
 712         Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
 713         assertTrue(underTestSpy.configExport(configExportInput).isDone());
 714     }
 715
 716     @Test
 717     public void stopApplicationTestParseException() {
 718         StopApplicationInput stopApplicationInput = mock(StopApplicationInput.class);
 719         Mockito.doReturn(Action.StopApplication).when(stopApplicationInput).getAction();
 720         Mockito.doReturn(getCommonHeaderBuilder().build()).when(stopApplicationInput)
 721                 .getCommonHeader();
 722         assertTrue(underTest.stopApplication(stopApplicationInput).isDone());
 723     }
 724
 725     @Test
 726     public void stopApplicationTest() {
 727         AppcProviderLcm underTestSpy = Mockito.spy(underTest);
 728         StopApplicationInput stopApplicationInput = mock(StopApplicationInput.class);
 729         Mockito.doReturn(Action.StopApplication).when(stopApplicationInput).getAction();
 730         Mockito.doReturn(getCommonHeaderBuilder().build()).when(stopApplicationInput).getCommonHeader();
 731         Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(stopApplicationInput).getActionIdentifiers();
 732         Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
 733         assertTrue(underTestSpy.stopApplication(stopApplicationInput).isDone());
 734     }
 735
 736     @Test
 737     public void closeTest() throws Exception {
 738         underTest.close();
 739         Mockito.verify(rpcRegistration).close();
 740     }
 741
 742     private CommonHeaderBuilder getCommonHeaderBuilder() {
 743         CommonHeaderBuilder headerBuilder = new CommonHeaderBuilder();
 744         headerBuilder.setApiVer("API-VERSION");
 745         headerBuilder.setTimestamp(ZULU.getDefaultInstance("1970-01-01T00:00:00.000Z"));
 746         headerBuilder.setOriginatorId("ORIGINATOR-ID");
 747         headerBuilder.setRequestId("REQUEST-ID");
 748         return headerBuilder;
 749     }
 750 }