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