2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2018-2019 Ericsson
6 * ================================================================================
7 * Modifications Copyright (C) 2019 Orange Nokia
8 * ================================================================================
9 * Licensed under the Apache License, Version 2.0 (the "License");
10 * you may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
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.mdsal.binding.api.DataBroker;
38 import org.opendaylight.mdsal.binding.api.NotificationPublishService;
39 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
40 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RpcRegistration;
41 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
42 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.Action;
43 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ActionStatusInput;
44 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AppcProviderLcmService;
45 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AttachVolumeInput;
46 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AuditInput;
47 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.CheckLockInput;
48 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigBackupDeleteInput;
49 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigBackupInput;
50 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigExportInput;
51 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigModifyInput;
52 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigRestoreInput;
53 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigScaleOutInput;
54 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigureInput;
55 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.DetachVolumeInput;
56 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.DistributeTrafficInput;
57 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.DistributeTrafficCheckInput;
58 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.EvacuateInput;
59 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.HealthCheckInput;
60 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.LiveUpgradeInput;
61 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.LockInput;
62 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.MigrateInput;
63 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.QueryInput;
64 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.QuiesceTrafficInput;
65 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RebootInput;
66 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RebuildInput;
67 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RestartInput;
68 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ResumeTrafficInput;
69 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RollbackInput;
70 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SnapshotInput;
71 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SoftwareUploadInput;
72 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StartApplicationInput;
73 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StartInput;
74 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StopApplicationInput;
75 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StopInput;
76 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SyncInput;
77 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.TerminateInput;
78 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.TestInput;
79 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UnlockInput;
80 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeBackoutInput;
81 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeBackupInput;
82 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradePostCheckInput;
83 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradePreCheckInput;
84 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeSoftwareInput;
85 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigScaleInInput;
86 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ZULU;
87 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.action.identifiers.ActionIdentifiersBuilder;
88 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.common.header.CommonHeaderBuilder;
91 public class AppcProviderLcmTest {
93 private interface ParameterizedRpcRegistration extends RpcRegistration<AppcProviderLcmService> {}
94 private DataBroker dataBroker;
95 private NotificationPublishService notificationProviderService;
96 private RpcProviderRegistry rpcProviderRegistry;
97 private BindingAwareBroker.RpcRegistration<AppcProviderLcmService> rpcRegistration;
98 private AppcProviderLcm underTest;
99 private RequestHandlerOutput output;
102 public void setupMocksForTests() {
103 dataBroker = mock(DataBroker.class);
104 notificationProviderService = mock(NotificationPublishService.class);
105 rpcProviderRegistry = mock(RpcProviderRegistry.class);
106 rpcRegistration = mock(ParameterizedRpcRegistration.class);
107 Mockito.doReturn(rpcRegistration).when(rpcProviderRegistry).addRpcImplementation(
108 Mockito.any(Class.class), Mockito.any(AppcProviderLcm.class));
110 new AppcProviderLcm(dataBroker, notificationProviderService, rpcProviderRegistry);
111 output = Mockito.mock(RequestHandlerOutput.class);
112 ResponseContext responseContext = Mockito.mock(ResponseContext.class);
113 Status status = Mockito.mock(Status.class);
114 Mockito.doReturn(200).when(status).getCode();
115 Mockito.doReturn(status).when(responseContext).getStatus();
116 Mockito.doReturn(responseContext).when(output).getResponseContext();
120 public void rebuildTestParseException() {
121 RebuildInput rebuildInput = mock(RebuildInput.class);
122 Mockito.doReturn(Action.Rebuild).when(rebuildInput).getAction();
123 Mockito.doReturn(getCommonHeaderBuilder().build()).when(rebuildInput).getCommonHeader();
124 assertTrue(underTest.rebuild(rebuildInput).isDone());
128 public void rebuildTest() {
129 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
130 RebuildInput rebuildInput = mock(RebuildInput.class);
131 Mockito.doReturn(Action.Rebuild).when(rebuildInput).getAction();
132 Mockito.doReturn(getCommonHeaderBuilder().build()).when(rebuildInput).getCommonHeader();
133 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(rebuildInput).getActionIdentifiers();
134 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
135 assertTrue(underTestSpy.rebuild(rebuildInput).isDone());
139 public void restartTestParseException() {
140 RestartInput restartInput = mock(RestartInput.class);
141 Mockito.doReturn(Action.Restart).when(restartInput).getAction();
142 Mockito.doReturn(getCommonHeaderBuilder().build()).when(restartInput).getCommonHeader();
143 assertTrue(underTest.restart(restartInput).isDone());
147 public void restartTest() {
148 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
149 RestartInput restartInput = mock(RestartInput.class);
150 Mockito.doReturn(Action.Restart).when(restartInput).getAction();
151 Mockito.doReturn(getCommonHeaderBuilder().build()).when(restartInput).getCommonHeader();
152 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(restartInput).getActionIdentifiers();
153 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
154 assertTrue(underTestSpy.restart(restartInput).isDone());
158 public void startApplicationTestParseException() {
159 StartApplicationInput startApplicationInput = mock(StartApplicationInput.class);
160 Mockito.doReturn(Action.StartApplication).when(startApplicationInput).getAction();
161 Mockito.doReturn(getCommonHeaderBuilder().build()).when(startApplicationInput)
163 assertTrue(underTest.startApplication(startApplicationInput).isDone());
167 public void startApplicationTest() {
168 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
169 StartApplicationInput startApplicationInput = mock(StartApplicationInput.class);
170 Mockito.doReturn(Action.StartApplication).when(startApplicationInput).getAction();
171 Mockito.doReturn(getCommonHeaderBuilder().build()).when(startApplicationInput).getCommonHeader();
172 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(startApplicationInput).getActionIdentifiers();
173 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
174 assertTrue(underTestSpy.startApplication(startApplicationInput).isDone());
178 public void migrateTestParseException() {
179 MigrateInput migrateInput = mock(MigrateInput.class);
180 Mockito.doReturn(Action.Migrate).when(migrateInput).getAction();
181 Mockito.doReturn(getCommonHeaderBuilder().build()).when(migrateInput).getCommonHeader();
182 assertTrue(underTest.migrate(migrateInput).isDone());
186 public void migrateTest() {
187 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
188 MigrateInput migrateInput = mock(MigrateInput.class);
189 Mockito.doReturn(Action.Migrate).when(migrateInput).getAction();
190 Mockito.doReturn(getCommonHeaderBuilder().build()).when(migrateInput).getCommonHeader();
191 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(migrateInput).getActionIdentifiers();
192 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
193 assertTrue(underTestSpy.migrate(migrateInput).isDone());
197 public void evacuateTestParseException() {
198 EvacuateInput evacuateInput = mock(EvacuateInput.class);
199 Mockito.doReturn(Action.Evacuate).when(evacuateInput).getAction();
200 Mockito.doReturn(getCommonHeaderBuilder().build()).when(evacuateInput).getCommonHeader();
201 assertTrue(underTest.evacuate(evacuateInput).isDone());
205 public void evacuateTest() {
206 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
207 EvacuateInput evacuateInput = mock(EvacuateInput.class);
208 Mockito.doReturn(Action.Evacuate).when(evacuateInput).getAction();
209 Mockito.doReturn(getCommonHeaderBuilder().build()).when(evacuateInput).getCommonHeader();
210 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(evacuateInput).getActionIdentifiers();
211 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
212 assertTrue(underTestSpy.evacuate(evacuateInput).isDone());
216 public void snapshotTestParseException() {
217 SnapshotInput snapshotInput = mock(SnapshotInput.class);
218 Mockito.doReturn(Action.Snapshot).when(snapshotInput).getAction();
219 Mockito.doReturn(getCommonHeaderBuilder().build()).when(snapshotInput).getCommonHeader();
220 assertTrue(underTest.snapshot(snapshotInput).isDone());
224 public void snapshotTest() {
225 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
226 SnapshotInput snapshotInput = mock(SnapshotInput.class);
227 Mockito.doReturn(Action.Snapshot).when(snapshotInput).getAction();
228 Mockito.doReturn(getCommonHeaderBuilder().build()).when(snapshotInput).getCommonHeader();
229 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(snapshotInput).getActionIdentifiers();
230 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
231 assertTrue(underTestSpy.snapshot(snapshotInput).isDone());
235 public void rollbackTestParseException() {
236 RollbackInput rollbackInput = mock(RollbackInput.class);
237 Mockito.doReturn(Action.Rollback).when(rollbackInput).getAction();
238 Mockito.doReturn(getCommonHeaderBuilder().build()).when(rollbackInput).getCommonHeader();
239 assertTrue(underTest.rollback(rollbackInput).isDone());
243 public void rollbackTest() {
244 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
245 RollbackInput rollbackInput = mock(RollbackInput.class);
246 Mockito.doReturn(Action.Rollback).when(rollbackInput).getAction();
247 Mockito.doReturn(getCommonHeaderBuilder().build()).when(rollbackInput).getCommonHeader();
248 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(rollbackInput).getActionIdentifiers();
249 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
250 assertTrue(underTestSpy.rollback(rollbackInput).isDone());
254 public void syncTestParseException() {
255 SyncInput syncInput = mock(SyncInput.class);
256 Mockito.doReturn(Action.Sync).when(syncInput).getAction();
257 Mockito.doReturn(getCommonHeaderBuilder().build()).when(syncInput).getCommonHeader();
258 assertTrue(underTest.sync(syncInput).isDone());
262 public void syncTest() {
263 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
264 SyncInput syncInput = mock(SyncInput.class);
265 Mockito.doReturn(Action.Sync).when(syncInput).getAction();
266 Mockito.doReturn(getCommonHeaderBuilder().build()).when(syncInput).getCommonHeader();
267 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(syncInput).getActionIdentifiers();
268 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
269 assertTrue(underTestSpy.sync(syncInput).isDone());
273 public void queryTest() {
274 QueryInput queryInput = mock(QueryInput.class);
275 Mockito.doReturn(Action.Query).when(queryInput).getAction();
276 assertTrue(underTest.query(queryInput).isDone());
280 public void attachVolumeTest() {
281 AttachVolumeInput attachVolumeInput = mock(AttachVolumeInput.class);
282 Mockito.doReturn(Action.AttachVolume).when(attachVolumeInput).getAction();
283 assertTrue(underTest.attachVolume(attachVolumeInput).isDone());
287 public void rebootTest() {
288 RebootInput rebootInput = mock(RebootInput.class);
289 Mockito.doReturn(Action.Reboot).when(rebootInput).getAction();
290 assertTrue(underTest.reboot(rebootInput).isDone());
294 public void detachVolumeTest() {
295 DetachVolumeInput detachVolumeInput = mock(DetachVolumeInput.class);
296 Mockito.doReturn(Action.DetachVolume).when(detachVolumeInput).getAction();
297 assertTrue(underTest.detachVolume(detachVolumeInput).isDone());
301 public void quiesceTrafficTest() {
302 QuiesceTrafficInput quiesceTrafficInput = mock(QuiesceTrafficInput.class);
303 Mockito.doReturn(Action.QuiesceTraffic).when(quiesceTrafficInput).getAction();
304 assertTrue(underTest.quiesceTraffic(quiesceTrafficInput).isDone());
308 public void resumeTrafficTest() {
309 ResumeTrafficInput resumeTrafficInput = mock(ResumeTrafficInput.class);
310 Mockito.doReturn(Action.ResumeTraffic).when(resumeTrafficInput).getAction();
311 assertTrue(underTest.resumeTraffic(resumeTrafficInput).isDone());
315 public void distributeTrafficTest() {
316 DistributeTrafficInput distributeTrafficInput = mock(DistributeTrafficInput.class);
317 Mockito.doReturn(Action.DistributeTraffic).when(distributeTrafficInput).getAction();
318 assertTrue(underTest.distributeTraffic(distributeTrafficInput).isDone());
322 public void distributeTrafficCheckTest() {
323 DistributeTrafficCheckInput distributeTrafficCheckInput = mock(DistributeTrafficCheckInput.class);
324 Mockito.doReturn(Action.DistributeTrafficCheck).when(distributeTrafficCheckInput).getAction();
325 assertTrue(underTest.distributeTrafficCheck(distributeTrafficCheckInput).isDone());
329 public void upgradePreCheckInputTest() {
330 UpgradePreCheckInput upgradePreCheckInput = mock(UpgradePreCheckInput.class);
331 Mockito.doReturn(Action.UpgradePreCheck).when(upgradePreCheckInput).getAction();
332 assertTrue(underTest.upgradePreCheck(upgradePreCheckInput).isDone());
336 public void upgradeSoftwareTest() {
337 UpgradeSoftwareInput upgradeSoftwareInput = mock(UpgradeSoftwareInput.class);
338 Mockito.doReturn(Action.UpgradeSoftware).when(upgradeSoftwareInput).getAction();
339 assertTrue(underTest.upgradeSoftware(upgradeSoftwareInput).isDone());
343 public void upgradePostCheckTest() {
344 UpgradePostCheckInput upgradePostCheckInput = mock(UpgradePostCheckInput.class);
345 Mockito.doReturn(Action.UpgradePostCheck).when(upgradePostCheckInput).getAction();
346 assertTrue(underTest.upgradePostCheck(upgradePostCheckInput).isDone());
350 public void upgradeBackupTest() {
351 UpgradeBackupInput upgradeBackupInput = mock(UpgradeBackupInput.class);
352 Mockito.doReturn(Action.UpgradeBackup).when(upgradeBackupInput).getAction();
353 assertTrue(underTest.upgradeBackup(upgradeBackupInput).isDone());
357 public void upgradeBackoutTest() {
358 UpgradeBackoutInput upgradeBackoutInput = mock(UpgradeBackoutInput.class);
359 Mockito.doReturn(Action.UpgradeBackout).when(upgradeBackoutInput).getAction();
360 assertTrue(underTest.upgradeBackout(upgradeBackoutInput).isDone());
364 public void terminateTestParseException() {
365 TerminateInput terminateInput = mock(TerminateInput.class);
366 Mockito.doReturn(Action.Terminate).when(terminateInput).getAction();
367 Mockito.doReturn(getCommonHeaderBuilder().build()).when(terminateInput).getCommonHeader();
368 assertTrue(underTest.terminate(terminateInput).isDone());
372 public void terminateTest() {
373 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
374 TerminateInput terminateInput = mock(TerminateInput.class);
375 Mockito.doReturn(Action.Terminate).when(terminateInput).getAction();
376 Mockito.doReturn(getCommonHeaderBuilder().build()).when(terminateInput).getCommonHeader();
377 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(terminateInput).getActionIdentifiers();
378 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
379 assertTrue(underTestSpy.terminate(terminateInput).isDone());
383 public void configScaleOutTest() {
384 ConfigScaleOutInput configScaleOutInput = mock(ConfigScaleOutInput.class);
385 Mockito.doReturn(Action.ConfigScaleOut).when(configScaleOutInput).getAction();
386 Mockito.doReturn(getCommonHeaderBuilder().build()).when(configScaleOutInput)
388 assertTrue(underTest.configScaleOut(configScaleOutInput).isDone());
392 public void configModifyTestParseException() {
393 ConfigModifyInput configModifyInput = mock(ConfigModifyInput.class);
394 Mockito.doReturn(Action.ConfigModify).when(configModifyInput).getAction();
395 Mockito.doReturn(getCommonHeaderBuilder().build()).when(configModifyInput)
397 assertTrue(underTest.configModify(configModifyInput).isDone());
401 public void configModifyTest() {
402 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
403 ConfigModifyInput configModifyInput = mock(ConfigModifyInput.class);
404 Mockito.doReturn(Action.ConfigModify).when(configModifyInput).getAction();
405 Mockito.doReturn(getCommonHeaderBuilder().build()).when(configModifyInput).getCommonHeader();
406 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(configModifyInput).getActionIdentifiers();
407 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
408 assertTrue(underTestSpy.configModify(configModifyInput).isDone());
412 public void actionStatusTest() {
413 ActionStatusInput actionStatusInput = mock(ActionStatusInput.class);
414 Mockito.doReturn(Action.ActionStatus).when(actionStatusInput).getAction();
415 assertTrue(underTest.actionStatus(actionStatusInput).isDone());
419 public void configRestoreTestParseException() {
420 ConfigRestoreInput configRestoreInput = mock(ConfigRestoreInput.class);
421 Mockito.doReturn(Action.ConfigRestore).when(configRestoreInput).getAction();
422 Mockito.doReturn(getCommonHeaderBuilder().build()).when(configRestoreInput)
424 assertTrue(underTest.configRestore(configRestoreInput).isDone());
428 public void configRestoreTest() {
429 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
430 ConfigRestoreInput configRestoreInput = mock(ConfigRestoreInput.class);
431 Mockito.doReturn(Action.ConfigRestore).when(configRestoreInput).getAction();
432 Mockito.doReturn(getCommonHeaderBuilder().build()).when(configRestoreInput).getCommonHeader();
433 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(configRestoreInput).getActionIdentifiers();
434 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
435 assertTrue(underTestSpy.configRestore(configRestoreInput).isDone());
439 public void configureTestParseException() {
440 ConfigureInput configureInput = mock(ConfigureInput.class);
441 Mockito.doReturn(Action.Configure).when(configureInput).getAction();
442 Mockito.doReturn(getCommonHeaderBuilder().build()).when(configureInput).getCommonHeader();
443 assertTrue(underTest.configure(configureInput).isDone());
447 public void configureTest() {
448 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
449 ConfigureInput configureInput = mock(ConfigureInput.class);
450 Mockito.doReturn(Action.Configure).when(configureInput).getAction();
451 Mockito.doReturn(getCommonHeaderBuilder().build()).when(configureInput).getCommonHeader();
452 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(configureInput).getActionIdentifiers();
453 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
454 assertTrue(underTestSpy.configure(configureInput).isDone());
458 public void testTestParseException() {
459 TestInput testInput = mock(TestInput.class);
460 Mockito.doReturn(Action.Test).when(testInput).getAction();
461 Mockito.doReturn(getCommonHeaderBuilder().build()).when(testInput).getCommonHeader();
462 assertTrue(underTest.test(testInput).isDone());
466 public void testTest() {
467 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
468 TestInput testInput = mock(TestInput.class);
469 Mockito.doReturn(Action.Test).when(testInput).getAction();
470 Mockito.doReturn(getCommonHeaderBuilder().build()).when(testInput).getCommonHeader();
471 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(testInput).getActionIdentifiers();
472 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
473 assertTrue(underTestSpy.test(testInput).isDone());
477 public void stopTestParseException() {
478 StopInput stopInput = mock(StopInput.class);
479 Mockito.doReturn(Action.Stop).when(stopInput).getAction();
480 Mockito.doReturn(getCommonHeaderBuilder().build()).when(stopInput).getCommonHeader();
481 assertTrue(underTest.stop(stopInput).isDone());
485 public void stopTest() {
486 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
487 StopInput stopInput = mock(StopInput.class);
488 Mockito.doReturn(Action.Stop).when(stopInput).getAction();
489 Mockito.doReturn(getCommonHeaderBuilder().build()).when(stopInput).getCommonHeader();
490 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(stopInput).getActionIdentifiers();
491 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
492 assertTrue(underTestSpy.stop(stopInput).isDone());
496 public void startTestParseException() {
497 StartInput startInput = mock(StartInput.class);
498 Mockito.doReturn(Action.Start).when(startInput).getAction();
499 Mockito.doReturn(getCommonHeaderBuilder().build()).when(startInput).getCommonHeader();
500 assertTrue(underTest.start(startInput).isDone());
504 public void startTest() {
505 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
506 StartInput startInput = mock(StartInput.class);
507 Mockito.doReturn(Action.Rebuild).when(startInput).getAction();
508 Mockito.doReturn(getCommonHeaderBuilder().build()).when(startInput).getCommonHeader();
509 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(startInput).getActionIdentifiers();
510 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
511 assertTrue(underTestSpy.start(startInput).isDone());
515 public void auditTestParseExcpetion() {
516 AuditInput auditInput = mock(AuditInput.class);
517 Mockito.doReturn(Action.Audit).when(auditInput).getAction();
518 Mockito.doReturn(getCommonHeaderBuilder().build()).when(auditInput).getCommonHeader();
519 assertTrue(underTest.audit(auditInput).isDone());
523 public void auditTest() {
524 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
525 AuditInput auditInput = mock(AuditInput.class);
526 Mockito.doReturn(Action.Audit).when(auditInput).getAction();
527 Mockito.doReturn(getCommonHeaderBuilder().build()).when(auditInput).getCommonHeader();
528 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(auditInput).getActionIdentifiers();
529 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
530 assertTrue(underTestSpy.audit(auditInput).isDone());
534 public void softwareUploadTestParseException() {
535 SoftwareUploadInput softwareUploadInput = mock(SoftwareUploadInput.class);
536 Mockito.doReturn(Action.SoftwareUpload).when(softwareUploadInput).getAction();
537 Mockito.doReturn(getCommonHeaderBuilder().build()).when(softwareUploadInput)
539 assertTrue(underTest.softwareUpload(softwareUploadInput).isDone());
543 public void softwareUploadTest() {
544 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
545 SoftwareUploadInput softwareUploadInput = mock(SoftwareUploadInput.class);
546 Mockito.doReturn(Action.SoftwareUpload).when(softwareUploadInput).getAction();
547 Mockito.doReturn(getCommonHeaderBuilder().build()).when(softwareUploadInput).getCommonHeader();
548 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(softwareUploadInput).getActionIdentifiers();
549 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
550 assertTrue(underTestSpy.softwareUpload(softwareUploadInput).isDone());
554 public void healthCheckTestParseException() {
555 HealthCheckInput healthCheckInput = mock(HealthCheckInput.class);
556 Mockito.doReturn(Action.HealthCheck).when(healthCheckInput).getAction();
557 Mockito.doReturn(getCommonHeaderBuilder().build()).when(healthCheckInput).getCommonHeader();
558 assertTrue(underTest.healthCheck(healthCheckInput).isDone());
562 public void healthCheckTest() {
563 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
564 HealthCheckInput healthCheckInput = mock(HealthCheckInput.class);
565 Mockito.doReturn(Action.HealthCheck).when(healthCheckInput).getAction();
566 Mockito.doReturn(getCommonHeaderBuilder().build()).when(healthCheckInput).getCommonHeader();
567 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(healthCheckInput).getActionIdentifiers();
568 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
569 assertTrue(underTestSpy.healthCheck(healthCheckInput).isDone());
573 public void liveUpgradeTestParseException() {
574 LiveUpgradeInput liveUpgradeInput = mock(LiveUpgradeInput.class);
575 Mockito.doReturn(Action.LiveUpgrade).when(liveUpgradeInput).getAction();
576 Mockito.doReturn(getCommonHeaderBuilder().build()).when(liveUpgradeInput).getCommonHeader();
577 assertTrue(underTest.liveUpgrade(liveUpgradeInput).isDone());
581 public void liveUpgradeTest() {
582 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
583 LiveUpgradeInput liveUpgradeInput = mock(LiveUpgradeInput.class);
584 Mockito.doReturn(Action.LiveUpgrade).when(liveUpgradeInput).getAction();
585 Mockito.doReturn(getCommonHeaderBuilder().build()).when(liveUpgradeInput).getCommonHeader();
586 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(liveUpgradeInput).getActionIdentifiers();
587 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
588 assertTrue(underTestSpy.liveUpgrade(liveUpgradeInput).isDone());
592 public void lockTestParseException() {
593 LockInput lockInput = mock(LockInput.class);
594 Mockito.doReturn(Action.Lock).when(lockInput).getAction();
595 Mockito.doReturn(getCommonHeaderBuilder().build()).when(lockInput).getCommonHeader();
596 assertTrue(underTest.lock(lockInput).isDone());
600 public void lockTest() {
601 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
602 LockInput lockInput = mock(LockInput.class);
603 Mockito.doReturn(Action.LiveUpgrade).when(lockInput).getAction();
604 Mockito.doReturn(getCommonHeaderBuilder().build()).when(lockInput).getCommonHeader();
605 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(lockInput).getActionIdentifiers();
606 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
607 assertTrue(underTestSpy.lock(lockInput).isDone());
611 public void unlockTestParseException() {
612 UnlockInput unlockInput = mock(UnlockInput.class);
613 Mockito.doReturn(Action.Unlock).when(unlockInput).getAction();
614 Mockito.doReturn(getCommonHeaderBuilder().build()).when(unlockInput).getCommonHeader();
615 assertTrue(underTest.unlock(unlockInput).isDone());
619 public void unLockTest() {
620 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
621 UnlockInput unlockInput = mock(UnlockInput.class);
622 Mockito.doReturn(Action.Unlock).when(unlockInput).getAction();
623 Mockito.doReturn(getCommonHeaderBuilder().build()).when(unlockInput).getCommonHeader();
624 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(unlockInput).getActionIdentifiers();
625 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
626 assertTrue(underTestSpy.unlock(unlockInput).isDone());
630 public void checkLockTestParseException() {
631 CheckLockInput checkLockInput = mock(CheckLockInput.class);
632 Mockito.doReturn(Action.CheckLock).when(checkLockInput).getAction();
633 Mockito.doReturn(getCommonHeaderBuilder().build()).when(checkLockInput).getCommonHeader();
634 assertTrue(underTest.checkLock(checkLockInput).isDone());
638 public void checkLockTest() {
639 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
640 CheckLockInput checkLockInput = mock(CheckLockInput.class);
641 Mockito.doReturn(Action.CheckLock).when(checkLockInput).getAction();
642 Mockito.doReturn(getCommonHeaderBuilder().build()).when(checkLockInput).getCommonHeader();
643 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(checkLockInput).getActionIdentifiers();
644 RequestHandlerOutput output = Mockito.mock(RequestHandlerOutput.class);
645 ResponseContext responseContext = Mockito.mock(ResponseContext.class);
646 Status status = Mockito.mock(Status.class);
647 Map<String, String> additionalContext = new HashMap<>();
648 additionalContext.put("locked", "true");
649 Mockito.doReturn(additionalContext).when(responseContext).getAdditionalContext();
650 Mockito.doReturn(400).when(status).getCode();
651 Mockito.doReturn(status).when(responseContext).getStatus();
652 Mockito.doReturn(responseContext).when(output).getResponseContext();
653 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
654 assertTrue(underTestSpy.checkLock(checkLockInput).isDone());
658 public void configBackupTestParseException() {
659 ConfigBackupInput configBackupInput = mock(ConfigBackupInput.class);
660 Mockito.doReturn(Action.ConfigBackup).when(configBackupInput).getAction();
661 Mockito.doReturn(getCommonHeaderBuilder().build()).when(configBackupInput)
663 assertTrue(underTest.configBackup(configBackupInput).isDone());
667 public void configBackupTest() {
668 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
669 ConfigBackupInput configBackupInput = mock(ConfigBackupInput.class);
670 Mockito.doReturn(Action.ConfigBackup).when(configBackupInput).getAction();
671 Mockito.doReturn(getCommonHeaderBuilder().build()).when(configBackupInput).getCommonHeader();
672 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(configBackupInput).getActionIdentifiers();
673 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
674 assertTrue(underTestSpy.configBackup(configBackupInput).isDone());
678 public void configBackupDeleteTestParseException() {
679 ConfigBackupDeleteInput configBackupDeleteInput = mock(ConfigBackupDeleteInput.class);
680 Mockito.doReturn(Action.ConfigBackupDelete).when(configBackupDeleteInput).getAction();
681 Mockito.doReturn(getCommonHeaderBuilder().build()).when(configBackupDeleteInput)
683 assertTrue(underTest.configBackupDelete(configBackupDeleteInput).isDone());
687 public void configBackupDeleteTest() {
688 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
689 ConfigBackupDeleteInput configBackupDeleteInput = mock(ConfigBackupDeleteInput.class);
690 Mockito.doReturn(Action.ConfigBackupDelete).when(configBackupDeleteInput).getAction();
691 Mockito.doReturn(getCommonHeaderBuilder().build()).when(configBackupDeleteInput).getCommonHeader();
692 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(configBackupDeleteInput).getActionIdentifiers();
693 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
694 assertTrue(underTestSpy.configBackupDelete(configBackupDeleteInput).isDone());
698 public void configExportTestParseException() {
699 ConfigExportInput configExportInput = mock(ConfigExportInput.class);
700 Mockito.doReturn(Action.ConfigExport).when(configExportInput).getAction();
701 Mockito.doReturn(getCommonHeaderBuilder().build()).when(configExportInput)
703 assertTrue(underTest.configExport(configExportInput).isDone());
707 public void configExportTest() {
708 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
709 ConfigExportInput configExportInput = mock(ConfigExportInput.class);
710 Mockito.doReturn(Action.ConfigExport).when(configExportInput).getAction();
711 Mockito.doReturn(getCommonHeaderBuilder().build()).when(configExportInput).getCommonHeader();
712 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(configExportInput).getActionIdentifiers();
713 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
714 assertTrue(underTestSpy.configExport(configExportInput).isDone());
718 public void stopApplicationTestParseException() {
719 StopApplicationInput stopApplicationInput = mock(StopApplicationInput.class);
720 Mockito.doReturn(Action.StopApplication).when(stopApplicationInput).getAction();
721 Mockito.doReturn(getCommonHeaderBuilder().build()).when(stopApplicationInput)
723 assertTrue(underTest.stopApplication(stopApplicationInput).isDone());
727 public void stopApplicationTest() {
728 AppcProviderLcm underTestSpy = Mockito.spy(underTest);
729 StopApplicationInput stopApplicationInput = mock(StopApplicationInput.class);
730 Mockito.doReturn(Action.StopApplication).when(stopApplicationInput).getAction();
731 Mockito.doReturn(getCommonHeaderBuilder().build()).when(stopApplicationInput).getCommonHeader();
732 Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(stopApplicationInput).getActionIdentifiers();
733 Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
734 assertTrue(underTestSpy.stopApplication(stopApplicationInput).isDone());
738 public void closeTest() throws Exception {
740 Mockito.verify(rpcRegistration).close();
744 public void configScaleInTest() {
745 ConfigScaleInInput configScaleInInput = mock(ConfigScaleInInput.class);
746 Mockito.doReturn(Action.ConfigScaleIn).when(configScaleInInput).getAction();
747 Mockito.doReturn(getCommonHeaderBuilder().build()).when(configScaleInInput)
749 assertTrue(underTest.configScaleIn(configScaleInInput).isDone());
752 private CommonHeaderBuilder getCommonHeaderBuilder() {
753 CommonHeaderBuilder headerBuilder = new CommonHeaderBuilder();
754 headerBuilder.setApiVer("API-VERSION");
755 headerBuilder.setTimestamp(ZULU.getDefaultInstance("1970-01-01T00:00:00.000Z"));
756 headerBuilder.setOriginatorId("ORIGINATOR-ID");
757 headerBuilder.setRequestId("REQUEST-ID");
758 return headerBuilder;