2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2018-2019 Ericsson
6 * ================================================================================
7 * Modifications Copyright (C) 2019 Orange
8 * ================================================================================
9 * Licensed under the Apache License, Version 2.0 (the "License");
10 * you may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
13 * http://www.apache.org/licenses/LICENSE-2.0
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.
21 * ============LICENSE_END=========================================================
24 package org.onap.appc.provider;
26 import static org.junit.Assert.assertTrue;
27 import static org.mockito.Mockito.mock;
28 import java.util.HashMap;
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.controller.md.sal.binding.api.DataBroker;
38 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
39 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
40 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RpcRegistration;
41 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
42 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.Action;
43 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ActionStatusInput;
44 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AppcProviderLcmService;
45 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AttachVolumeInput;
46 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AuditInput;
47 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.CheckLockInput;
48 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigBackupDeleteInput;
49 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigBackupInput;
50 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigExportInput;
51 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigModifyInput;
52 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigRestoreInput;
53 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigScaleOutInput;
54 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigureInput;
55 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.DetachVolumeInput;
56 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.DistributeTrafficInput;
57 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.DistributeTrafficCheckInput;
58 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.EvacuateInput;
59 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.HealthCheckInput;
60 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.LiveUpgradeInput;
61 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.LockInput;
62 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.MigrateInput;
63 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.QueryInput;
64 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.QuiesceTrafficInput;
65 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RebootInput;
66 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RebuildInput;
67 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RestartInput;
68 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ResumeTrafficInput;
69 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RollbackInput;
70 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SnapshotInput;
71 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SoftwareUploadInput;
72 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StartApplicationInput;
73 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StartInput;
74 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StopApplicationInput;
75 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StopInput;
76 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SyncInput;
77 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.TerminateInput;
78 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.TestInput;
79 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UnlockInput;
80 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeBackoutInput;
81 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeBackupInput;
82 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradePostCheckInput;
83 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradePreCheckInput;
84 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeSoftwareInput;
85 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ZULU;
86 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.action.identifiers.ActionIdentifiersBuilder;
87 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.common.header.CommonHeaderBuilder;
90 public class AppcProviderLcmTest {
92 private interface ParameterizedRpcRegistration extends RpcRegistration<AppcProviderLcmService> {}
93 private DataBroker dataBroker;
94 private NotificationPublishService notificationProviderService;
95 private RpcProviderRegistry rpcProviderRegistry;
96 private BindingAwareBroker.RpcRegistration<AppcProviderLcmService> rpcRegistration;
97 private AppcProviderLcm underTest;
98 private RequestHandlerOutput output;
101 public void setupMocksForTests() {
102 dataBroker = mock(DataBroker.class);
103 notificationProviderService = mock(NotificationPublishService.class);
104 rpcProviderRegistry = mock(RpcProviderRegistry.class);
105 rpcRegistration = mock(ParameterizedRpcRegistration.class);
106 Mockito.doReturn(rpcRegistration).when(rpcProviderRegistry).addRpcImplementation(
107 Mockito.any(Class.class), Mockito.any(AppcProviderLcm.class));
109 new AppcProviderLcm(dataBroker, notificationProviderService, rpcProviderRegistry);
110 output = Mockito.mock(RequestHandlerOutput.class);
111 ResponseContext responseContext = Mockito.mock(ResponseContext.class);
112 Status status = Mockito.mock(Status.class);
113 Mockito.doReturn(200).when(status).getCode();
114 Mockito.doReturn(status).when(responseContext).getStatus();
115 Mockito.doReturn(responseContext).when(output).getResponseContext();
119 public void rebuildTestParseException() {
120 RebuildInput rebuildInput = mock(RebuildInput.class);
121 Mockito.doReturn(Action.Rebuild).when(rebuildInput).getAction();
122 Mockito.doReturn(getCommonHeaderBuilder().build()).when(rebuildInput).getCommonHeader();
123 assertTrue(underTest.rebuild(rebuildInput).isDone());
127 public void rebuildTest() {
128 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
129 RebuildInput rebuildInput = mock(RebuildInput.class);
130 Mockito.doReturn(Action.Rebuild).when(rebuildInput).getAction();
131 Mockito.doReturn(getCommonHeaderBuilder().build()).when(rebuildInput).getCommonHeader();
132 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(rebuildInput).getActionIdentifiers();
133 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
134 assertTrue(underTestSpy.rebuild(rebuildInput).isDone());
138 public void restartTestParseException() {
139 RestartInput restartInput = mock(RestartInput.class);
140 Mockito.doReturn(Action.Restart).when(restartInput).getAction();
141 Mockito.doReturn(getCommonHeaderBuilder().build()).when(restartInput).getCommonHeader();
142 assertTrue(underTest.restart(restartInput).isDone());
146 public void restartTest() {
147 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
148 RestartInput restartInput = mock(RestartInput.class);
149 Mockito.doReturn(Action.Restart).when(restartInput).getAction();
150 Mockito.doReturn(getCommonHeaderBuilder().build()).when(restartInput).getCommonHeader();
151 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(restartInput).getActionIdentifiers();
152 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
153 assertTrue(underTestSpy.restart(restartInput).isDone());
157 public void startApplicationTestParseException() {
158 StartApplicationInput startApplicationInput = mock(StartApplicationInput.class);
159 Mockito.doReturn(Action.StartApplication).when(startApplicationInput).getAction();
160 Mockito.doReturn(getCommonHeaderBuilder().build()).when(startApplicationInput)
162 assertTrue(underTest.startApplication(startApplicationInput).isDone());
166 public void startApplicationTest() {
167 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
168 StartApplicationInput startApplicationInput = mock(StartApplicationInput.class);
169 Mockito.doReturn(Action.StartApplication).when(startApplicationInput).getAction();
170 Mockito.doReturn(getCommonHeaderBuilder().build()).when(startApplicationInput).getCommonHeader();
171 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(startApplicationInput).getActionIdentifiers();
172 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
173 assertTrue(underTestSpy.startApplication(startApplicationInput).isDone());
177 public void migrateTestParseException() {
178 MigrateInput migrateInput = mock(MigrateInput.class);
179 Mockito.doReturn(Action.Migrate).when(migrateInput).getAction();
180 Mockito.doReturn(getCommonHeaderBuilder().build()).when(migrateInput).getCommonHeader();
181 assertTrue(underTest.migrate(migrateInput).isDone());
185 public void migrateTest() {
186 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
187 MigrateInput migrateInput = mock(MigrateInput.class);
188 Mockito.doReturn(Action.Migrate).when(migrateInput).getAction();
189 Mockito.doReturn(getCommonHeaderBuilder().build()).when(migrateInput).getCommonHeader();
190 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(migrateInput).getActionIdentifiers();
191 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
192 assertTrue(underTestSpy.migrate(migrateInput).isDone());
196 public void evacuateTestParseException() {
197 EvacuateInput evacuateInput = mock(EvacuateInput.class);
198 Mockito.doReturn(Action.Evacuate).when(evacuateInput).getAction();
199 Mockito.doReturn(getCommonHeaderBuilder().build()).when(evacuateInput).getCommonHeader();
200 assertTrue(underTest.evacuate(evacuateInput).isDone());
204 public void evacuateTest() {
205 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
206 EvacuateInput evacuateInput = mock(EvacuateInput.class);
207 Mockito.doReturn(Action.Evacuate).when(evacuateInput).getAction();
208 Mockito.doReturn(getCommonHeaderBuilder().build()).when(evacuateInput).getCommonHeader();
209 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(evacuateInput).getActionIdentifiers();
210 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
211 assertTrue(underTestSpy.evacuate(evacuateInput).isDone());
215 public void snapshotTestParseException() {
216 SnapshotInput snapshotInput = mock(SnapshotInput.class);
217 Mockito.doReturn(Action.Snapshot).when(snapshotInput).getAction();
218 Mockito.doReturn(getCommonHeaderBuilder().build()).when(snapshotInput).getCommonHeader();
219 assertTrue(underTest.snapshot(snapshotInput).isDone());
223 public void snapshotTest() {
224 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
225 SnapshotInput snapshotInput = mock(SnapshotInput.class);
226 Mockito.doReturn(Action.Snapshot).when(snapshotInput).getAction();
227 Mockito.doReturn(getCommonHeaderBuilder().build()).when(snapshotInput).getCommonHeader();
228 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(snapshotInput).getActionIdentifiers();
229 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
230 assertTrue(underTestSpy.snapshot(snapshotInput).isDone());
234 public void rollbackTestParseException() {
235 RollbackInput rollbackInput = mock(RollbackInput.class);
236 Mockito.doReturn(Action.Rollback).when(rollbackInput).getAction();
237 Mockito.doReturn(getCommonHeaderBuilder().build()).when(rollbackInput).getCommonHeader();
238 assertTrue(underTest.rollback(rollbackInput).isDone());
242 public void rollbackTest() {
243 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
244 RollbackInput rollbackInput = mock(RollbackInput.class);
245 Mockito.doReturn(Action.Rollback).when(rollbackInput).getAction();
246 Mockito.doReturn(getCommonHeaderBuilder().build()).when(rollbackInput).getCommonHeader();
247 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(rollbackInput).getActionIdentifiers();
248 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
249 assertTrue(underTestSpy.rollback(rollbackInput).isDone());
253 public void syncTestParseException() {
254 SyncInput syncInput = mock(SyncInput.class);
255 Mockito.doReturn(Action.Sync).when(syncInput).getAction();
256 Mockito.doReturn(getCommonHeaderBuilder().build()).when(syncInput).getCommonHeader();
257 assertTrue(underTest.sync(syncInput).isDone());
261 public void syncTest() {
262 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
263 SyncInput syncInput = mock(SyncInput.class);
264 Mockito.doReturn(Action.Sync).when(syncInput).getAction();
265 Mockito.doReturn(getCommonHeaderBuilder().build()).when(syncInput).getCommonHeader();
266 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(syncInput).getActionIdentifiers();
267 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
268 assertTrue(underTestSpy.sync(syncInput).isDone());
272 public void queryTest() {
273 QueryInput queryInput = mock(QueryInput.class);
274 Mockito.doReturn(Action.Query).when(queryInput).getAction();
275 assertTrue(underTest.query(queryInput).isDone());
279 public void attachVolumeTest() {
280 AttachVolumeInput attachVolumeInput = mock(AttachVolumeInput.class);
281 Mockito.doReturn(Action.AttachVolume).when(attachVolumeInput).getAction();
282 assertTrue(underTest.attachVolume(attachVolumeInput).isDone());
286 public void rebootTest() {
287 RebootInput rebootInput = mock(RebootInput.class);
288 Mockito.doReturn(Action.Reboot).when(rebootInput).getAction();
289 assertTrue(underTest.reboot(rebootInput).isDone());
293 public void detachVolumeTest() {
294 DetachVolumeInput detachVolumeInput = mock(DetachVolumeInput.class);
295 Mockito.doReturn(Action.DetachVolume).when(detachVolumeInput).getAction();
296 assertTrue(underTest.detachVolume(detachVolumeInput).isDone());
300 public void quiesceTrafficTest() {
301 QuiesceTrafficInput quiesceTrafficInput = mock(QuiesceTrafficInput.class);
302 Mockito.doReturn(Action.QuiesceTraffic).when(quiesceTrafficInput).getAction();
303 assertTrue(underTest.quiesceTraffic(quiesceTrafficInput).isDone());
307 public void resumeTrafficTest() {
308 ResumeTrafficInput resumeTrafficInput = mock(ResumeTrafficInput.class);
309 Mockito.doReturn(Action.ResumeTraffic).when(resumeTrafficInput).getAction();
310 assertTrue(underTest.resumeTraffic(resumeTrafficInput).isDone());
314 public void distributeTrafficTest() {
315 DistributeTrafficInput distributeTrafficInput = mock(DistributeTrafficInput.class);
316 Mockito.doReturn(Action.DistributeTraffic).when(distributeTrafficInput).getAction();
317 assertTrue(underTest.distributeTraffic(distributeTrafficInput).isDone());
321 public void distributeTrafficCheckTest() {
322 DistributeTrafficCheckInput distributeTrafficCheckInput = mock(DistributeTrafficCheckInput.class);
323 Mockito.doReturn(Action.DistributeTrafficCheck).when(distributeTrafficCheckInput).getAction();
324 assertTrue(underTest.distributeTrafficCheck(distributeTrafficCheckInput).isDone());
328 public void upgradePreCheckInputTest() {
329 UpgradePreCheckInput upgradePreCheckInput = mock(UpgradePreCheckInput.class);
330 Mockito.doReturn(Action.UpgradePreCheck).when(upgradePreCheckInput).getAction();
331 assertTrue(underTest.upgradePreCheck(upgradePreCheckInput).isDone());
335 public void upgradeSoftwareTest() {
336 UpgradeSoftwareInput upgradeSoftwareInput = mock(UpgradeSoftwareInput.class);
337 Mockito.doReturn(Action.UpgradeSoftware).when(upgradeSoftwareInput).getAction();
338 assertTrue(underTest.upgradeSoftware(upgradeSoftwareInput).isDone());
342 public void upgradePostCheckTest() {
343 UpgradePostCheckInput upgradePostCheckInput = mock(UpgradePostCheckInput.class);
344 Mockito.doReturn(Action.UpgradePostCheck).when(upgradePostCheckInput).getAction();
345 assertTrue(underTest.upgradePostCheck(upgradePostCheckInput).isDone());
349 public void upgradeBackupTest() {
350 UpgradeBackupInput upgradeBackupInput = mock(UpgradeBackupInput.class);
351 Mockito.doReturn(Action.UpgradeBackup).when(upgradeBackupInput).getAction();
352 assertTrue(underTest.upgradeBackup(upgradeBackupInput).isDone());
356 public void upgradeBackoutTest() {
357 UpgradeBackoutInput upgradeBackoutInput = mock(UpgradeBackoutInput.class);
358 Mockito.doReturn(Action.UpgradeBackout).when(upgradeBackoutInput).getAction();
359 assertTrue(underTest.upgradeBackout(upgradeBackoutInput).isDone());
363 public void terminateTestParseException() {
364 TerminateInput terminateInput = mock(TerminateInput.class);
365 Mockito.doReturn(Action.Terminate).when(terminateInput).getAction();
366 Mockito.doReturn(getCommonHeaderBuilder().build()).when(terminateInput).getCommonHeader();
367 assertTrue(underTest.terminate(terminateInput).isDone());
371 public void terminateTest() {
372 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
373 TerminateInput terminateInput = mock(TerminateInput.class);
374 Mockito.doReturn(Action.Terminate).when(terminateInput).getAction();
375 Mockito.doReturn(getCommonHeaderBuilder().build()).when(terminateInput).getCommonHeader();
376 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(terminateInput).getActionIdentifiers();
377 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
378 assertTrue(underTestSpy.terminate(terminateInput).isDone());
382 public void configScaleOutTest() {
383 ConfigScaleOutInput configScaleOutInput = mock(ConfigScaleOutInput.class);
384 Mockito.doReturn(Action.ConfigScaleOut).when(configScaleOutInput).getAction();
385 Mockito.doReturn(getCommonHeaderBuilder().build()).when(configScaleOutInput)
387 assertTrue(underTest.configScaleOut(configScaleOutInput).isDone());
391 public void configModifyTestParseException() {
392 ConfigModifyInput configModifyInput = mock(ConfigModifyInput.class);
393 Mockito.doReturn(Action.ConfigModify).when(configModifyInput).getAction();
394 Mockito.doReturn(getCommonHeaderBuilder().build()).when(configModifyInput)
396 assertTrue(underTest.configModify(configModifyInput).isDone());
400 public void configModifyTest() {
401 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
402 ConfigModifyInput configModifyInput = mock(ConfigModifyInput.class);
403 Mockito.doReturn(Action.ConfigModify).when(configModifyInput).getAction();
404 Mockito.doReturn(getCommonHeaderBuilder().build()).when(configModifyInput).getCommonHeader();
405 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(configModifyInput).getActionIdentifiers();
406 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
407 assertTrue(underTestSpy.configModify(configModifyInput).isDone());
411 public void actionStatusTest() {
412 ActionStatusInput actionStatusInput = mock(ActionStatusInput.class);
413 Mockito.doReturn(Action.ActionStatus).when(actionStatusInput).getAction();
414 assertTrue(underTest.actionStatus(actionStatusInput).isDone());
418 public void configRestoreTestParseException() {
419 ConfigRestoreInput configRestoreInput = mock(ConfigRestoreInput.class);
420 Mockito.doReturn(Action.ConfigRestore).when(configRestoreInput).getAction();
421 Mockito.doReturn(getCommonHeaderBuilder().build()).when(configRestoreInput)
423 assertTrue(underTest.configRestore(configRestoreInput).isDone());
427 public void configRestoreTest() {
428 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
429 ConfigRestoreInput configRestoreInput = mock(ConfigRestoreInput.class);
430 Mockito.doReturn(Action.ConfigRestore).when(configRestoreInput).getAction();
431 Mockito.doReturn(getCommonHeaderBuilder().build()).when(configRestoreInput).getCommonHeader();
432 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(configRestoreInput).getActionIdentifiers();
433 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
434 assertTrue(underTestSpy.configRestore(configRestoreInput).isDone());
438 public void configureTestParseException() {
439 ConfigureInput configureInput = mock(ConfigureInput.class);
440 Mockito.doReturn(Action.Configure).when(configureInput).getAction();
441 Mockito.doReturn(getCommonHeaderBuilder().build()).when(configureInput).getCommonHeader();
442 assertTrue(underTest.configure(configureInput).isDone());
446 public void configureTest() {
447 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
448 ConfigureInput configureInput = mock(ConfigureInput.class);
449 Mockito.doReturn(Action.Configure).when(configureInput).getAction();
450 Mockito.doReturn(getCommonHeaderBuilder().build()).when(configureInput).getCommonHeader();
451 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(configureInput).getActionIdentifiers();
452 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
453 assertTrue(underTestSpy.configure(configureInput).isDone());
457 public void testTestParseException() {
458 TestInput testInput = mock(TestInput.class);
459 Mockito.doReturn(Action.Test).when(testInput).getAction();
460 Mockito.doReturn(getCommonHeaderBuilder().build()).when(testInput).getCommonHeader();
461 assertTrue(underTest.test(testInput).isDone());
465 public void testTest() {
466 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
467 TestInput testInput = mock(TestInput.class);
468 Mockito.doReturn(Action.Test).when(testInput).getAction();
469 Mockito.doReturn(getCommonHeaderBuilder().build()).when(testInput).getCommonHeader();
470 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(testInput).getActionIdentifiers();
471 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
472 assertTrue(underTestSpy.test(testInput).isDone());
476 public void stopTestParseException() {
477 StopInput stopInput = mock(StopInput.class);
478 Mockito.doReturn(Action.Stop).when(stopInput).getAction();
479 Mockito.doReturn(getCommonHeaderBuilder().build()).when(stopInput).getCommonHeader();
480 assertTrue(underTest.stop(stopInput).isDone());
484 public void stopTest() {
485 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
486 StopInput stopInput = mock(StopInput.class);
487 Mockito.doReturn(Action.Stop).when(stopInput).getAction();
488 Mockito.doReturn(getCommonHeaderBuilder().build()).when(stopInput).getCommonHeader();
489 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(stopInput).getActionIdentifiers();
490 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
491 assertTrue(underTestSpy.stop(stopInput).isDone());
495 public void startTestParseException() {
496 StartInput startInput = mock(StartInput.class);
497 Mockito.doReturn(Action.Start).when(startInput).getAction();
498 Mockito.doReturn(getCommonHeaderBuilder().build()).when(startInput).getCommonHeader();
499 assertTrue(underTest.start(startInput).isDone());
503 public void startTest() {
504 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
505 StartInput startInput = mock(StartInput.class);
506 Mockito.doReturn(Action.Rebuild).when(startInput).getAction();
507 Mockito.doReturn(getCommonHeaderBuilder().build()).when(startInput).getCommonHeader();
508 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(startInput).getActionIdentifiers();
509 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
510 assertTrue(underTestSpy.start(startInput).isDone());
514 public void auditTestParseExcpetion() {
515 AuditInput auditInput = mock(AuditInput.class);
516 Mockito.doReturn(Action.Audit).when(auditInput).getAction();
517 Mockito.doReturn(getCommonHeaderBuilder().build()).when(auditInput).getCommonHeader();
518 assertTrue(underTest.audit(auditInput).isDone());
522 public void auditTest() {
523 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
524 AuditInput auditInput = mock(AuditInput.class);
525 Mockito.doReturn(Action.Audit).when(auditInput).getAction();
526 Mockito.doReturn(getCommonHeaderBuilder().build()).when(auditInput).getCommonHeader();
527 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(auditInput).getActionIdentifiers();
528 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
529 assertTrue(underTestSpy.audit(auditInput).isDone());
533 public void softwareUploadTestParseException() {
534 SoftwareUploadInput softwareUploadInput = mock(SoftwareUploadInput.class);
535 Mockito.doReturn(Action.SoftwareUpload).when(softwareUploadInput).getAction();
536 Mockito.doReturn(getCommonHeaderBuilder().build()).when(softwareUploadInput)
538 assertTrue(underTest.softwareUpload(softwareUploadInput).isDone());
542 public void softwareUploadTest() {
543 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
544 SoftwareUploadInput softwareUploadInput = mock(SoftwareUploadInput.class);
545 Mockito.doReturn(Action.SoftwareUpload).when(softwareUploadInput).getAction();
546 Mockito.doReturn(getCommonHeaderBuilder().build()).when(softwareUploadInput).getCommonHeader();
547 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(softwareUploadInput).getActionIdentifiers();
548 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
549 assertTrue(underTestSpy.softwareUpload(softwareUploadInput).isDone());
553 public void healthCheckTestParseException() {
554 HealthCheckInput healthCheckInput = mock(HealthCheckInput.class);
555 Mockito.doReturn(Action.HealthCheck).when(healthCheckInput).getAction();
556 Mockito.doReturn(getCommonHeaderBuilder().build()).when(healthCheckInput).getCommonHeader();
557 assertTrue(underTest.healthCheck(healthCheckInput).isDone());
561 public void healthCheckTest() {
562 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
563 HealthCheckInput healthCheckInput = mock(HealthCheckInput.class);
564 Mockito.doReturn(Action.HealthCheck).when(healthCheckInput).getAction();
565 Mockito.doReturn(getCommonHeaderBuilder().build()).when(healthCheckInput).getCommonHeader();
566 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(healthCheckInput).getActionIdentifiers();
567 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
568 assertTrue(underTestSpy.healthCheck(healthCheckInput).isDone());
572 public void liveUpgradeTestParseException() {
573 LiveUpgradeInput liveUpgradeInput = mock(LiveUpgradeInput.class);
574 Mockito.doReturn(Action.LiveUpgrade).when(liveUpgradeInput).getAction();
575 Mockito.doReturn(getCommonHeaderBuilder().build()).when(liveUpgradeInput).getCommonHeader();
576 assertTrue(underTest.liveUpgrade(liveUpgradeInput).isDone());
580 public void liveUpgradeTest() {
581 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
582 LiveUpgradeInput liveUpgradeInput = mock(LiveUpgradeInput.class);
583 Mockito.doReturn(Action.LiveUpgrade).when(liveUpgradeInput).getAction();
584 Mockito.doReturn(getCommonHeaderBuilder().build()).when(liveUpgradeInput).getCommonHeader();
585 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(liveUpgradeInput).getActionIdentifiers();
586 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
587 assertTrue(underTestSpy.liveUpgrade(liveUpgradeInput).isDone());
591 public void lockTestParseException() {
592 LockInput lockInput = mock(LockInput.class);
593 Mockito.doReturn(Action.Lock).when(lockInput).getAction();
594 Mockito.doReturn(getCommonHeaderBuilder().build()).when(lockInput).getCommonHeader();
595 assertTrue(underTest.lock(lockInput).isDone());
599 public void lockTest() {
600 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
601 LockInput lockInput = mock(LockInput.class);
602 Mockito.doReturn(Action.LiveUpgrade).when(lockInput).getAction();
603 Mockito.doReturn(getCommonHeaderBuilder().build()).when(lockInput).getCommonHeader();
604 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(lockInput).getActionIdentifiers();
605 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
606 assertTrue(underTestSpy.lock(lockInput).isDone());
610 public void unlockTestParseException() {
611 UnlockInput unlockInput = mock(UnlockInput.class);
612 Mockito.doReturn(Action.Unlock).when(unlockInput).getAction();
613 Mockito.doReturn(getCommonHeaderBuilder().build()).when(unlockInput).getCommonHeader();
614 assertTrue(underTest.unlock(unlockInput).isDone());
618 public void unLockTest() {
619 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
620 UnlockInput unlockInput = mock(UnlockInput.class);
621 Mockito.doReturn(Action.Unlock).when(unlockInput).getAction();
622 Mockito.doReturn(getCommonHeaderBuilder().build()).when(unlockInput).getCommonHeader();
623 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(unlockInput).getActionIdentifiers();
624 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
625 assertTrue(underTestSpy.unlock(unlockInput).isDone());
629 public void checkLockTestParseException() {
630 CheckLockInput checkLockInput = mock(CheckLockInput.class);
631 Mockito.doReturn(Action.CheckLock).when(checkLockInput).getAction();
632 Mockito.doReturn(getCommonHeaderBuilder().build()).when(checkLockInput).getCommonHeader();
633 assertTrue(underTest.checkLock(checkLockInput).isDone());
637 public void checkLockTest() {
638 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
639 CheckLockInput checkLockInput = mock(CheckLockInput.class);
640 Mockito.doReturn(Action.CheckLock).when(checkLockInput).getAction();
641 Mockito.doReturn(getCommonHeaderBuilder().build()).when(checkLockInput).getCommonHeader();
642 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(checkLockInput).getActionIdentifiers();
643 RequestHandlerOutput output = Mockito.mock(RequestHandlerOutput.class);
644 ResponseContext responseContext = Mockito.mock(ResponseContext.class);
645 Status status = Mockito.mock(Status.class);
646 Map<String, String> additionalContext = new HashMap<>();
647 additionalContext.put("locked", "true");
648 Mockito.doReturn(additionalContext).when(responseContext).getAdditionalContext();
649 Mockito.doReturn(400).when(status).getCode();
650 Mockito.doReturn(status).when(responseContext).getStatus();
651 Mockito.doReturn(responseContext).when(output).getResponseContext();
652 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
653 assertTrue(underTestSpy.checkLock(checkLockInput).isDone());
657 public void configBackupTestParseException() {
658 ConfigBackupInput configBackupInput = mock(ConfigBackupInput.class);
659 Mockito.doReturn(Action.ConfigBackup).when(configBackupInput).getAction();
660 Mockito.doReturn(getCommonHeaderBuilder().build()).when(configBackupInput)
662 assertTrue(underTest.configBackup(configBackupInput).isDone());
666 public void configBackupTest() {
667 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
668 ConfigBackupInput configBackupInput = mock(ConfigBackupInput.class);
669 Mockito.doReturn(Action.ConfigBackup).when(configBackupInput).getAction();
670 Mockito.doReturn(getCommonHeaderBuilder().build()).when(configBackupInput).getCommonHeader();
671 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(configBackupInput).getActionIdentifiers();
672 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
673 assertTrue(underTestSpy.configBackup(configBackupInput).isDone());
677 public void configBackupDeleteTestParseException() {
678 ConfigBackupDeleteInput configBackupDeleteInput = mock(ConfigBackupDeleteInput.class);
679 Mockito.doReturn(Action.ConfigBackupDelete).when(configBackupDeleteInput).getAction();
680 Mockito.doReturn(getCommonHeaderBuilder().build()).when(configBackupDeleteInput)
682 assertTrue(underTest.configBackupDelete(configBackupDeleteInput).isDone());
686 public void configBackupDeleteTest() {
687 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
688 ConfigBackupDeleteInput configBackupDeleteInput = mock(ConfigBackupDeleteInput.class);
689 Mockito.doReturn(Action.ConfigBackupDelete).when(configBackupDeleteInput).getAction();
690 Mockito.doReturn(getCommonHeaderBuilder().build()).when(configBackupDeleteInput).getCommonHeader();
691 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(configBackupDeleteInput).getActionIdentifiers();
692 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
693 assertTrue(underTestSpy.configBackupDelete(configBackupDeleteInput).isDone());
697 public void configExportTestParseException() {
698 ConfigExportInput configExportInput = mock(ConfigExportInput.class);
699 Mockito.doReturn(Action.ConfigExport).when(configExportInput).getAction();
700 Mockito.doReturn(getCommonHeaderBuilder().build()).when(configExportInput)
702 assertTrue(underTest.configExport(configExportInput).isDone());
706 public void configExportTest() {
707 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
708 ConfigExportInput configExportInput = mock(ConfigExportInput.class);
709 Mockito.doReturn(Action.ConfigExport).when(configExportInput).getAction();
710 Mockito.doReturn(getCommonHeaderBuilder().build()).when(configExportInput).getCommonHeader();
711 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(configExportInput).getActionIdentifiers();
712 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
713 assertTrue(underTestSpy.configExport(configExportInput).isDone());
717 public void stopApplicationTestParseException() {
718 StopApplicationInput stopApplicationInput = mock(StopApplicationInput.class);
719 Mockito.doReturn(Action.StopApplication).when(stopApplicationInput).getAction();
720 Mockito.doReturn(getCommonHeaderBuilder().build()).when(stopApplicationInput)
722 assertTrue(underTest.stopApplication(stopApplicationInput).isDone());
726 public void stopApplicationTest() {
727 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
728 StopApplicationInput stopApplicationInput = mock(StopApplicationInput.class);
729 Mockito.doReturn(Action.StopApplication).when(stopApplicationInput).getAction();
730 Mockito.doReturn(getCommonHeaderBuilder().build()).when(stopApplicationInput).getCommonHeader();
731 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(stopApplicationInput).getActionIdentifiers();
732 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
733 assertTrue(underTestSpy.stopApplication(stopApplicationInput).isDone());
737 public void closeTest() throws Exception {
739 Mockito.verify(rpcRegistration).close();
742 private CommonHeaderBuilder getCommonHeaderBuilder() {
743 CommonHeaderBuilder headerBuilder = new CommonHeaderBuilder();
744 headerBuilder.setApiVer("API-VERSION");
745 headerBuilder.setTimestamp(ZULU.getDefaultInstance("1970-01-01T00:00:00.000Z"));
746 headerBuilder.setOriginatorId("ORIGINATOR-ID");
747 headerBuilder.setRequestId("REQUEST-ID");
748 return headerBuilder;