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 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.Matchers.eq;
  26 import static org.mockito.Mockito.mock;
  27 import org.junit.Before;
  28 import org.junit.Test;
  29 import org.mockito.Mockito;
  30 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  31 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
  32 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
  33 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RpcRegistration;
  34 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
  35 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.Action;
  36 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ActionStatusInput;
  37 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AppcProviderLcmService;
  38 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AttachVolumeInput;
  39 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AuditInput;
  40 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.CheckLockInput;
  41 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigBackupDeleteInput;
  42 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigBackupInput;
  43 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigExportInput;
  44 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigModifyInput;
  45 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigRestoreInput;
  46 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigScaleOutInput;
  47 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigureInput;
  48 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.DetachVolumeInput;
  49 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.DistributeTrafficInput;
  50 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.EvacuateInput;
  51 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.HealthCheckInput;
  52 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.LiveUpgradeInput;
  53 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.LockInput;
  54 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.MigrateInput;
  55 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.QueryInput;
  56 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.QuiesceTrafficInput;
  57 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RebootInput;
  58 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RebuildInput;
  59 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RestartInput;
  60 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ResumeTrafficInput;
  61 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RollbackInput;
  62 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SnapshotInput;
  63 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SoftwareUploadInput;
  64 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StartApplicationInput;
  65 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StartInput;
  66 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StopApplicationInput;
  67 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StopInput;
  68 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SyncInput;
  69 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.TerminateInput;
  70 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.TestInput;
  71 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UnlockInput;
  72 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeBackoutInput;
  73 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeBackupInput;
  74 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradePostCheckInput;
  75 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradePreCheckInput;
  76 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeSoftwareInput;
  77 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ZULU;
  78 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.common.header.CommonHeaderBuilder;
  79
  80
  81 public class AppcProviderLcmTest {
  82
  83     private interface ParameterizedRpcRegistration extends RpcRegistration<AppcProviderLcmService> {}
  84     private DataBroker dataBroker;
  85     private NotificationPublishService notificationProviderService;
  86     private RpcProviderRegistry rpcProviderRegistry;
  87     private BindingAwareBroker.RpcRegistration<AppcProviderLcmService> rpcRegistration;
  88     private AppcProviderLcm underTest;
  89
  90     @Before
  91     public void setupMocksForTests() {
  92         dataBroker = mock(DataBroker.class);
  93         notificationProviderService = mock(NotificationPublishService.class);
  94         rpcProviderRegistry = mock(RpcProviderRegistry.class);
  95         rpcRegistration = mock(ParameterizedRpcRegistration.class);
  96         Mockito.doReturn(rpcRegistration).when(rpcProviderRegistry).addRpcImplementation(
  97                 eq(AppcProviderLcm.class), Mockito.any(AppcProviderLcm.class));
  98         underTest =
  99                 new AppcProviderLcm(dataBroker, notificationProviderService, rpcProviderRegistry);
 100     }
 101
 102     @Test
 103     public void rebuildTest() {
 104         RebuildInput rebuildInput = mock(RebuildInput.class);
 105         Mockito.doReturn(Action.Rebuild).when(rebuildInput).getAction();
 106         Mockito.doReturn(getCommonHeaderBuilder().build()).when(rebuildInput).getCommonHeader();
 107         assertTrue(underTest.rebuild(rebuildInput).isDone());
 108     }
 109
 110     @Test
 111     public void restartTest() {
 112         RestartInput restartInput = mock(RestartInput.class);
 113         Mockito.doReturn(Action.Restart).when(restartInput).getAction();
 114         Mockito.doReturn(getCommonHeaderBuilder().build()).when(restartInput).getCommonHeader();
 115         assertTrue(underTest.restart(restartInput).isDone());
 116     }
 117
 118     @Test
 119     public void startApplicationTest() {
 120         StartApplicationInput startApplicationInput = mock(StartApplicationInput.class);
 121         Mockito.doReturn(Action.StartApplication).when(startApplicationInput).getAction();
 122         Mockito.doReturn(getCommonHeaderBuilder().build()).when(startApplicationInput)
 123                 .getCommonHeader();
 124         assertTrue(underTest.startApplication(startApplicationInput).isDone());
 125     }
 126
 127     @Test
 128     public void migrateTest() {
 129         MigrateInput migrateInput = mock(MigrateInput.class);
 130         Mockito.doReturn(Action.Migrate).when(migrateInput).getAction();
 131         Mockito.doReturn(getCommonHeaderBuilder().build()).when(migrateInput).getCommonHeader();
 132         assertTrue(underTest.migrate(migrateInput).isDone());
 133     }
 134
 135     @Test
 136     public void evacuateTest() {
 137         EvacuateInput evacuateInput = mock(EvacuateInput.class);
 138         Mockito.doReturn(Action.Evacuate).when(evacuateInput).getAction();
 139         Mockito.doReturn(getCommonHeaderBuilder().build()).when(evacuateInput).getCommonHeader();
 140         assertTrue(underTest.evacuate(evacuateInput).isDone());
 141     }
 142
 143     @Test
 144     public void snapshotTest() {
 145         SnapshotInput snapshotInput = mock(SnapshotInput.class);
 146         Mockito.doReturn(Action.Snapshot).when(snapshotInput).getAction();
 147         Mockito.doReturn(getCommonHeaderBuilder().build()).when(snapshotInput).getCommonHeader();
 148         assertTrue(underTest.snapshot(snapshotInput).isDone());
 149     }
 150
 151     @Test
 152     public void rollbackTest() {
 153         RollbackInput rollbackInput = mock(RollbackInput.class);
 154         Mockito.doReturn(Action.Rollback).when(rollbackInput).getAction();
 155         Mockito.doReturn(getCommonHeaderBuilder().build()).when(rollbackInput).getCommonHeader();
 156         assertTrue(underTest.rollback(rollbackInput).isDone());
 157     }
 158
 159     @Test
 160     public void syncTest() {
 161         SyncInput syncInput = mock(SyncInput.class);
 162         Mockito.doReturn(Action.Sync).when(syncInput).getAction();
 163         Mockito.doReturn(getCommonHeaderBuilder().build()).when(syncInput).getCommonHeader();
 164         assertTrue(underTest.sync(syncInput).isDone());
 165     }
 166
 167     @Test
 168     public void queryTest() {
 169         QueryInput queryInput = mock(QueryInput.class);
 170         Mockito.doReturn(Action.Query).when(queryInput).getAction();
 171         assertTrue(underTest.query(queryInput).isDone());
 172     }
 173
 174     @Test
 175     public void attachVolumeTest() {
 176         AttachVolumeInput attachVolumeInput = mock(AttachVolumeInput.class);
 177         Mockito.doReturn(Action.AttachVolume).when(attachVolumeInput).getAction();
 178         assertTrue(underTest.attachVolume(attachVolumeInput).isDone());
 179     }
 180
 181     @Test
 182     public void rebootTest() {
 183         RebootInput rebootInput = mock(RebootInput.class);
 184         Mockito.doReturn(Action.Reboot).when(rebootInput).getAction();
 185         assertTrue(underTest.reboot(rebootInput).isDone());
 186     }
 187
 188     @Test
 189     public void detachVolumeTest() {
 190         DetachVolumeInput detachVolumeInput = mock(DetachVolumeInput.class);
 191         Mockito.doReturn(Action.DetachVolume).when(detachVolumeInput).getAction();
 192         assertTrue(underTest.detachVolume(detachVolumeInput).isDone());
 193     }
 194
 195     @Test
 196     public void quiesceTrafficTest() {
 197         QuiesceTrafficInput quiesceTrafficInput = mock(QuiesceTrafficInput.class);
 198         Mockito.doReturn(Action.QuiesceTraffic).when(quiesceTrafficInput).getAction();
 199         assertTrue(underTest.quiesceTraffic(quiesceTrafficInput).isDone());
 200     }
 201
 202     @Test
 203     public void resumeTrafficTest() {
 204         ResumeTrafficInput resumeTrafficInput = mock(ResumeTrafficInput.class);
 205         Mockito.doReturn(Action.ResumeTraffic).when(resumeTrafficInput).getAction();
 206         assertTrue(underTest.resumeTraffic(resumeTrafficInput).isDone());
 207     }
 208
 209     @Test
 210     public void distributeTrafficTest() {
 211         DistributeTrafficInput distributeTrafficInput = mock(DistributeTrafficInput.class);
 212         Mockito.doReturn(Action.DistributeTraffic).when(distributeTrafficInput).getAction();
 213         assertTrue(underTest.distributeTraffic(distributeTrafficInput).isDone());
 214     }
 215
 216     @Test
 217     public void upgradePreCheckInputTest() {
 218         UpgradePreCheckInput upgradePreCheckInput = mock(UpgradePreCheckInput.class);
 219         Mockito.doReturn(Action.UpgradePreCheck).when(upgradePreCheckInput).getAction();
 220         assertTrue(underTest.upgradePreCheck(upgradePreCheckInput).isDone());
 221     }
 222
 223     @Test
 224     public void upgradeSoftwareTest() {
 225         UpgradeSoftwareInput upgradeSoftwareInput = mock(UpgradeSoftwareInput.class);
 226         Mockito.doReturn(Action.UpgradeSoftware).when(upgradeSoftwareInput).getAction();
 227         assertTrue(underTest.upgradeSoftware(upgradeSoftwareInput).isDone());
 228     }
 229
 230     @Test
 231     public void upgradePostCheckTest() {
 232         UpgradePostCheckInput upgradePostCheckInput = mock(UpgradePostCheckInput.class);
 233         Mockito.doReturn(Action.UpgradePostCheck).when(upgradePostCheckInput).getAction();
 234         assertTrue(underTest.upgradePostCheck(upgradePostCheckInput).isDone());
 235     }
 236
 237     @Test
 238     public void upgradeBackupTest() {
 239         UpgradeBackupInput upgradeBackupInput = mock(UpgradeBackupInput.class);
 240         Mockito.doReturn(Action.UpgradeBackup).when(upgradeBackupInput).getAction();
 241         assertTrue(underTest.upgradeBackup(upgradeBackupInput).isDone());
 242     }
 243
 244     @Test
 245     public void upgradeBackoutTest() {
 246         UpgradeBackoutInput upgradeBackoutInput = mock(UpgradeBackoutInput.class);
 247         Mockito.doReturn(Action.UpgradeBackout).when(upgradeBackoutInput).getAction();
 248         assertTrue(underTest.upgradeBackout(upgradeBackoutInput).isDone());
 249     }
 250
 251     @Test
 252     public void terminateTest() {
 253         TerminateInput terminateInput = mock(TerminateInput.class);
 254         Mockito.doReturn(Action.Terminate).when(terminateInput).getAction();
 255         Mockito.doReturn(getCommonHeaderBuilder().build()).when(terminateInput).getCommonHeader();
 256         assertTrue(underTest.terminate(terminateInput).isDone());
 257     }
 258
 259     @Test
 260     public void configScaleOutTest() {
 261         ConfigScaleOutInput configScaleOutInput = mock(ConfigScaleOutInput.class);
 262         Mockito.doReturn(Action.ConfigScaleOut).when(configScaleOutInput).getAction();
 263         Mockito.doReturn(getCommonHeaderBuilder().build()).when(configScaleOutInput)
 264                 .getCommonHeader();
 265         assertTrue(underTest.configScaleOut(configScaleOutInput).isDone());
 266     }
 267
 268     @Test
 269     public void configModifyTest() {
 270         ConfigModifyInput configModifyInput = mock(ConfigModifyInput.class);
 271         Mockito.doReturn(Action.ConfigModify).when(configModifyInput).getAction();
 272         Mockito.doReturn(getCommonHeaderBuilder().build()).when(configModifyInput)
 273                 .getCommonHeader();
 274         assertTrue(underTest.configModify(configModifyInput).isDone());
 275     }
 276
 277     @Test
 278     public void actionStatusTest() {
 279         ActionStatusInput actionStatusInput = mock(ActionStatusInput.class);
 280         Mockito.doReturn(Action.ActionStatus).when(actionStatusInput).getAction();
 281         assertTrue(underTest.actionStatus(actionStatusInput).isDone());
 282     }
 283
 284     @Test
 285     public void configRestoreTest() {
 286         ConfigRestoreInput configRestoreInput = mock(ConfigRestoreInput.class);
 287         Mockito.doReturn(Action.ConfigRestore).when(configRestoreInput).getAction();
 288         Mockito.doReturn(getCommonHeaderBuilder().build()).when(configRestoreInput)
 289                 .getCommonHeader();
 290         assertTrue(underTest.configRestore(configRestoreInput).isDone());
 291     }
 292
 293     @Test
 294     public void configureTest() {
 295         ConfigureInput configureInput = mock(ConfigureInput.class);
 296         Mockito.doReturn(Action.Configure).when(configureInput).getAction();
 297         Mockito.doReturn(getCommonHeaderBuilder().build()).when(configureInput).getCommonHeader();
 298         assertTrue(underTest.configure(configureInput).isDone());
 299     }
 300
 301     @Test
 302     public void testTest() {
 303         TestInput testInput = mock(TestInput.class);
 304         Mockito.doReturn(Action.Test).when(testInput).getAction();
 305         Mockito.doReturn(getCommonHeaderBuilder().build()).when(testInput).getCommonHeader();
 306         assertTrue(underTest.test(testInput).isDone());
 307     }
 308
 309     @Test
 310     public void stopTest() {
 311         StopInput stopInput = mock(StopInput.class);
 312         Mockito.doReturn(Action.Stop).when(stopInput).getAction();
 313         Mockito.doReturn(getCommonHeaderBuilder().build()).when(stopInput).getCommonHeader();
 314         assertTrue(underTest.stop(stopInput).isDone());
 315     }
 316
 317     @Test
 318     public void startTest() {
 319         StartInput startInput = mock(StartInput.class);
 320         Mockito.doReturn(Action.Start).when(startInput).getAction();
 321         Mockito.doReturn(getCommonHeaderBuilder().build()).when(startInput).getCommonHeader();
 322         assertTrue(underTest.start(startInput).isDone());
 323     }
 324
 325     @Test
 326     public void auditTest() {
 327         AuditInput auditInput = mock(AuditInput.class);
 328         Mockito.doReturn(Action.Audit).when(auditInput).getAction();
 329         Mockito.doReturn(getCommonHeaderBuilder().build()).when(auditInput).getCommonHeader();
 330         assertTrue(underTest.audit(auditInput).isDone());
 331     }
 332
 333     @Test
 334     public void softwareUploadTest() {
 335         SoftwareUploadInput softwareUploadInput = mock(SoftwareUploadInput.class);
 336         Mockito.doReturn(Action.SoftwareUpload).when(softwareUploadInput).getAction();
 337         Mockito.doReturn(getCommonHeaderBuilder().build()).when(softwareUploadInput)
 338                 .getCommonHeader();
 339         assertTrue(underTest.softwareUpload(softwareUploadInput).isDone());
 340     }
 341
 342     @Test
 343     public void healthCheckTest() {
 344         HealthCheckInput healthCheckInput = mock(HealthCheckInput.class);
 345         Mockito.doReturn(Action.HealthCheck).when(healthCheckInput).getAction();
 346         Mockito.doReturn(getCommonHeaderBuilder().build()).when(healthCheckInput).getCommonHeader();
 347         assertTrue(underTest.healthCheck(healthCheckInput).isDone());
 348     }
 349
 350     @Test
 351     public void liveUpgradeTest() {
 352         LiveUpgradeInput liveUpgradeInput = mock(LiveUpgradeInput.class);
 353         Mockito.doReturn(Action.LiveUpgrade).when(liveUpgradeInput).getAction();
 354         Mockito.doReturn(getCommonHeaderBuilder().build()).when(liveUpgradeInput).getCommonHeader();
 355         assertTrue(underTest.liveUpgrade(liveUpgradeInput).isDone());
 356     }
 357
 358     @Test
 359     public void lockTest() {
 360         LockInput lockInput = mock(LockInput.class);
 361         Mockito.doReturn(Action.Lock).when(lockInput).getAction();
 362         Mockito.doReturn(getCommonHeaderBuilder().build()).when(lockInput).getCommonHeader();
 363         assertTrue(underTest.lock(lockInput).isDone());
 364     }
 365
 366     @Test
 367     public void unlockTest() {
 368         UnlockInput unlockInput = mock(UnlockInput.class);
 369         Mockito.doReturn(Action.Unlock).when(unlockInput).getAction();
 370         Mockito.doReturn(getCommonHeaderBuilder().build()).when(unlockInput).getCommonHeader();
 371         assertTrue(underTest.unlock(unlockInput).isDone());
 372     }
 373
 374     @Test
 375     public void checkLockTest() {
 376         CheckLockInput checkLockInput = mock(CheckLockInput.class);
 377         Mockito.doReturn(Action.CheckLock).when(checkLockInput).getAction();
 378         Mockito.doReturn(getCommonHeaderBuilder().build()).when(checkLockInput).getCommonHeader();
 379         assertTrue(underTest.checkLock(checkLockInput).isDone());
 380     }
 381
 382     @Test
 383     public void configBackupTest() {
 384         ConfigBackupInput configBackupInput = mock(ConfigBackupInput.class);
 385         Mockito.doReturn(Action.ConfigBackup).when(configBackupInput).getAction();
 386         Mockito.doReturn(getCommonHeaderBuilder().build()).when(configBackupInput)
 387                 .getCommonHeader();
 388         assertTrue(underTest.configBackup(configBackupInput).isDone());
 389     }
 390
 391     @Test
 392     public void configBackupDeleteTest() {
 393         ConfigBackupDeleteInput configBackupDeleteInput = mock(ConfigBackupDeleteInput.class);
 394         Mockito.doReturn(Action.ConfigBackupDelete).when(configBackupDeleteInput).getAction();
 395         Mockito.doReturn(getCommonHeaderBuilder().build()).when(configBackupDeleteInput)
 396                 .getCommonHeader();
 397         assertTrue(underTest.configBackupDelete(configBackupDeleteInput).isDone());
 398     }
 399
 400     @Test
 401     public void configExportTest() {
 402         ConfigExportInput configExportInput = mock(ConfigExportInput.class);
 403         Mockito.doReturn(Action.ConfigExport).when(configExportInput).getAction();
 404         Mockito.doReturn(getCommonHeaderBuilder().build()).when(configExportInput)
 405                 .getCommonHeader();
 406         assertTrue(underTest.configExport(configExportInput).isDone());
 407     }
 408
 409     @Test
 410     public void stopApplicationTest() {
 411         StopApplicationInput stopApplicationInput = mock(StopApplicationInput.class);
 412         Mockito.doReturn(Action.StopApplication).when(stopApplicationInput).getAction();
 413         Mockito.doReturn(getCommonHeaderBuilder().build()).when(stopApplicationInput)
 414                 .getCommonHeader();
 415         assertTrue(underTest.stopApplication(stopApplicationInput).isDone());
 416     }
 417
 418     private CommonHeaderBuilder getCommonHeaderBuilder() {
 419         CommonHeaderBuilder headerBuilder = new CommonHeaderBuilder();
 420         headerBuilder.setApiVer("API-VERSION");
 421         headerBuilder.setTimestamp(ZULU.getDefaultInstance("1970-01-01T00:00:00.000Z"));
 422         headerBuilder.setOriginatorId("ORIGINATOR-ID");
 423         headerBuilder.setRequestId("REQUEST-ID");
 424         return headerBuilder;
 425     }
 426 }