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