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