2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
6 * ================================================================================
7 * Copyright (C) 2017 Amdocs
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 org.junit.After;
27 import org.junit.Assert;
28 import org.junit.Before;
29 import org.junit.Test;
30 import org.junit.runner.RunWith;
31 import org.mockito.Mock;
32 import org.mockito.Spy;
33 import org.mockito.runners.MockitoJUnitRunner;
34 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
35 import org.opendaylight.controller.md.sal.binding.test.AbstractDataBrokerTest;
36 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
37 import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
38 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
39 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AttachVolumeInput;
40 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AttachVolumeOutput;
41 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AttachVolumeOutputBuilder;
42 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AuditInput;
43 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AuditOutput;
44 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.CheckLockInput;
45 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.CheckLockOutput;
46 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigBackupDeleteInput;
47 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigBackupDeleteOutput;
48 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigBackupInput;
49 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigBackupOutput;
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.ConfigExportOutput;
52 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigModifyInput;
53 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigModifyOutput;
54 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigRestoreInput;
55 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigRestoreOutput;
56 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigureInput;
57 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigureOutput;
58 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigScaleOutInput;
59 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigScaleOutOutput;
60 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigScaleOutOutputBuilder;
61 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.DetachVolumeInput;
62 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.DetachVolumeOutput;
63 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.DetachVolumeOutputBuilder;
64 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.EvacuateInput;
65 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.EvacuateOutput;
66 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.HealthCheckInput;
67 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.HealthCheckOutput;
68 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.LiveUpgradeInput;
69 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.LiveUpgradeOutput;
70 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.LockInput;
71 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.LockOutput;
72 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.MigrateInput;
73 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.MigrateOutput;
74 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.QueryInput;
75 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.QueryOutput;
76 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.QueryOutputBuilder;
77 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.QuiesceTrafficInput;
78 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.QuiesceTrafficOutput;
79 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.QuiesceTrafficOutputBuilder;
80 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ResumeTrafficInput;
81 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ResumeTrafficOutput;
82 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ResumeTrafficOutputBuilder;
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.UpgradePreCheckOutput;
85 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradePreCheckOutputBuilder;
86 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeSoftwareInput;
87 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeSoftwareOutput;
88 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeSoftwareOutputBuilder;
89 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradePostCheckInput;
90 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradePostCheckOutput;
91 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradePostCheckOutputBuilder;
92 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeBackupInput;
93 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeBackupOutput;
94 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeBackupOutputBuilder;
95 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeBackoutInput;
96 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeBackoutOutput;
97 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeBackoutOutputBuilder;
98 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RebootInput;
99 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RebootOutput;
100 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RebootOutputBuilder;
101 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RebuildInput;
102 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RebuildOutput;
103 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RestartInput;
104 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RestartOutput;
105 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RollbackInput;
106 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RollbackOutput;
107 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SnapshotInput;
108 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SnapshotOutput;
109 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SoftwareUploadInput;
110 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SoftwareUploadOutput;
111 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StartApplicationInput;
112 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StartApplicationOutput;
113 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StartInput;
114 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StartOutput;
115 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StopApplicationInput;
116 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StopApplicationOutput;
117 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StopInput;
118 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StopOutput;
119 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SyncInput;
120 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SyncOutput;
121 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.TerminateInput;
122 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.TerminateOutput;
123 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.TestInput;
124 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.TestOutput;
125 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UnlockInput;
126 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UnlockOutput;
127 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ZULU;
128 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.action.identifiers.ActionIdentifiers;
129 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.action.identifiers.ActionIdentifiersBuilder;
130 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.common.header.CommonHeader;
131 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.common.header.CommonHeaderBuilder;
132 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.status.Status;
133 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.status.StatusBuilder;
134 import org.opendaylight.yangtools.yang.common.RpcResult;
135 import org.onap.appc.domainmodel.lcm.ResponseContext;
136 import org.onap.appc.executor.objects.LCMCommandStatus;
137 import org.onap.appc.provider.lcm.service.*;
138 import org.onap.appc.provider.lcm.util.ValidationService;
139 import org.onap.appc.requesthandler.objects.RequestHandlerOutput;
140 import org.onap.appc.provider.Whitebox;
141 import java.text.DateFormat;
142 import java.text.SimpleDateFormat;
144 import java.util.HashMap;
145 import java.util.Map;
146 import java.util.TimeZone;
147 import java.util.concurrent.ExecutorService;
148 import java.util.concurrent.Executors;
149 import java.util.concurrent.Future;
151 import static org.mockito.Matchers.any;
152 import static org.mockito.Mockito.doReturn;
153 import static org.mockito.Mockito.mock;
154 import static org.mockito.Mockito.spy;
155 import static org.mockito.Mockito.times;
156 import static org.mockito.Mockito.verify;
157 import static org.mockito.Mockito.when;
160 * Integration Test class for AppcProviderLcm.
163 @SuppressWarnings("deprecation")
164 @RunWith(MockitoJUnitRunner.class)
165 public class AppcProviderLcmTest extends AbstractDataBrokerTest {
166 private Status successStatus = new StatusBuilder().setCode(400).setMessage("success").build();
167 private Status failStatus = new StatusBuilder().setCode(302)
168 .setMessage("MISSING MANDATORY PARAMETER - Parameter/s common-header , action is/are missing").build();
170 private AppcProviderLcm appcProviderLcm;
171 private DataBroker dataBroker;
173 private ValidationService validationService = ValidationService.getInstance();
175 private RequestHandlerOutput requestHandlerOutput;
177 private ResponseContext responseContext;
179 private org.onap.appc.domainmodel.lcm.Status successlcmStatus;
182 * The @Before annotation is defined in the AbstractDataBrokerTest class. The method setupWithDataBroker is invoked
183 * from inside the @Before method and is used to initialize the databroker with objects for a test runs. In our case
184 * we use this oportunity to create an instance of our provider and initialize it (which registers it as a listener
185 * etc). This method runs before every @Test method below.
188 protected void setupWithDataBroker(DataBroker dataBroker) {
189 super.setupWithDataBroker(dataBroker);
191 this.dataBroker = dataBroker;
195 public void setUp() throws Exception {
196 //mock appcProviderLcm
197 NotificationProviderService nps = mock(NotificationProviderService.class);
198 RpcProviderRegistry registry = mock(RpcProviderRegistry.class);
199 BindingAwareBroker.RpcRegistration rpcRegistration = mock(BindingAwareBroker.RpcRegistration.class);
200 doReturn(rpcRegistration).when(registry).addRpcImplementation(any(), any());
201 appcProviderLcm = spy(new AppcProviderLcm(dataBroker, nps, registry));
202 //mock validationService
203 //mockStatic(ValidationService.class);
204 //when(ValidationService.getInstance()).thenReturn(validationService);
206 doReturn(successlcmStatus).when(responseContext).getStatus();
207 doReturn(400).when(successlcmStatus).getCode();
208 doReturn("success").when(successlcmStatus).getMessage();
212 public void tearDown() throws Exception {
213 if (appcProviderLcm != null) {
214 appcProviderLcm.close();
219 public void testConstructor() throws Exception {
220 Object executorService = Whitebox.getInternalState(appcProviderLcm, "executor");
221 Assert.assertNotNull(executorService);
222 Object internalRpcRegistration = Whitebox.getInternalState(appcProviderLcm,
224 Assert.assertNotNull(internalRpcRegistration);
228 public void testClose() throws Exception {
229 ExecutorService executorService = spy(Executors.newFixedThreadPool(1));
230 Whitebox.setInternalState(appcProviderLcm, "executor", executorService);
231 BindingAwareBroker.RpcRegistration rpcRegistration = mock(BindingAwareBroker.RpcRegistration.class);
232 Whitebox.setInternalState(appcProviderLcm, "rpcRegistration", rpcRegistration);
233 appcProviderLcm.close();
234 verify(executorService, times(1)).shutdown();
235 verify(rpcRegistration, times(1)).close();
239 public void testRebuild() throws Exception {
240 // Validation success
241 doReturn("Success").when(successlcmStatus).getMessage();
242 doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
243 doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
244 doReturn(null).when(validationService).validateInput(any(), any(), any());
246 RebuildInput rebuildInput = mock(RebuildInput.class);
247 doReturn(newCommonHeader("request-id-test")).when(rebuildInput).getCommonHeader();
248 doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
249 .when(rebuildInput).getActionIdentifiers();
251 Future<RpcResult<RebuildOutput>> results = appcProviderLcm.rebuild(rebuildInput);
252 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
253 //Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
254 //verify(appcProviderLcm, times(1)).executeRequest(any());
257 doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
258 results = appcProviderLcm.rebuild(rebuildInput);
259 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
260 //Assert.assertEquals(failStatus, results.get().getResult().getStatus());
261 //verify(appcProviderLcm, times(1)).executeRequest(any());
264 doReturn(null).when(validationService).validateInput(any(), any(), any());
265 doReturn(null).when(rebuildInput).getActionIdentifiers();
266 results = appcProviderLcm.rebuild(rebuildInput);
267 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
268 Assert.assertTrue(303 == LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode());
269 //Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
270 // == results.get().getResult().getStatus().getCode());
271 //verify(appcProviderLcm, times(1)).executeRequest(any());
275 public void testRestart() throws Exception {
276 // Validation success
277 doReturn("Success").when(successlcmStatus).getMessage();
278 doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
279 doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
280 doReturn(null).when(validationService).validateInput(any(), any(), any());
282 RestartInput restartInput = mock(RestartInput.class);
283 doReturn(newCommonHeader("request-id-test")).when(restartInput).getCommonHeader();
284 doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
285 .when(restartInput).getActionIdentifiers();
287 Future<RpcResult<RestartOutput>> results = appcProviderLcm.restart(restartInput);
288 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
289 //Assert.assertEquals("Success", results.get().getResult());
290 //verify(appcProviderLcm, times(1)).executeRequest(any());
293 doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
294 results = appcProviderLcm.restart(restartInput);
295 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
296 //Assert.assertEquals(failStatus, results.get().getResult().getStatus());
297 //verify(appcProviderLcm, times(1)).executeRequest(any());
300 doReturn(null).when(validationService).validateInput(any(), any(), any());
301 doReturn(null).when(restartInput).getActionIdentifiers();
302 results = appcProviderLcm.restart(restartInput);
303 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
304 Assert.assertTrue(303 == LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode());
305 //Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
306 // == results.get().getResult().getStatus().getCode());
307 //verify(appcProviderLcm, times(1)).executeRequest(any());
311 public void testStartApplication() throws Exception {
312 // Validation success
313 doReturn("Success").when(successlcmStatus).getMessage();
314 doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
315 doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
316 doReturn(null).when(validationService).validateInput(any(), any(), any());
318 StartApplicationInput startApplicationInput = mock(StartApplicationInput.class);
319 doReturn(newCommonHeader("request-id-test")).when(startApplicationInput).getCommonHeader();
320 doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
321 .when(startApplicationInput).getActionIdentifiers();
323 Future<RpcResult<StartApplicationOutput>> results = appcProviderLcm.startApplication(startApplicationInput);
324 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
325 //Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
326 //verify(appcProviderLcm, times(1)).executeRequest(any());
329 doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
330 results = appcProviderLcm.startApplication(startApplicationInput);
331 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
332 //Assert.assertEquals(failStatus, results.get().getResult().getStatus());
333 //verify(appcProviderLcm, times(1)).executeRequest(any());
336 doReturn(null).when(validationService).validateInput(any(), any(), any());
337 doReturn(null).when(startApplicationInput).getActionIdentifiers();
338 results = appcProviderLcm.startApplication(startApplicationInput);
339 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
340 Assert.assertTrue(303 == LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode());
341 //Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
342 // == results.get().getResult().getStatus().getCode());
343 //verify(appcProviderLcm, times(1)).executeRequest(any());
347 public void testMigrate() throws Exception {
348 // Validation success
349 doReturn("Success").when(successlcmStatus).getMessage();
350 doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
351 doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
352 doReturn(null).when(validationService).validateInput(any(), any(), any());
354 MigrateInput migrateInput = mock(MigrateInput.class);
355 doReturn(newCommonHeader("request-id-test")).when(migrateInput).getCommonHeader();
356 doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
357 .when(migrateInput).getActionIdentifiers();
359 Future<RpcResult<MigrateOutput>> results = appcProviderLcm.migrate(migrateInput);
360 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
361 //Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
362 //verify(appcProviderLcm, times(1)).executeRequest(any());
365 doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
366 results = appcProviderLcm.migrate(migrateInput);
367 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
368 //Assert.assertEquals(failStatus, results.get().getResult().getStatus());
369 //verify(appcProviderLcm, times(1)).executeRequest(any());
372 doReturn(null).when(validationService).validateInput(any(), any(), any());
373 doReturn(null).when(migrateInput).getActionIdentifiers();
374 results = appcProviderLcm.migrate(migrateInput);
375 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
376 Assert.assertTrue(303 == LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode());
377 //Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
378 // == results.get().getResult().getStatus().getCode());
379 //verify(appcProviderLcm, times(1)).executeRequest(any());
383 public void testEvacuate() throws Exception {
384 // Validation success
385 doReturn("Success").when(successlcmStatus).getMessage();
386 doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
387 doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
388 doReturn(null).when(validationService).validateInput(any(), any(), any());
390 EvacuateInput evacuateInput = mock(EvacuateInput.class);
391 doReturn(newCommonHeader("request-id-test")).when(evacuateInput).getCommonHeader();
392 doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
393 .when(evacuateInput).getActionIdentifiers();
395 Future<RpcResult<EvacuateOutput>> results = appcProviderLcm.evacuate(evacuateInput);
396 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
397 //Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
398 //verify(appcProviderLcm, times(1)).executeRequest(any());
401 doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
402 results = appcProviderLcm.evacuate(evacuateInput);
403 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
404 //Assert.assertEquals(failStatus, results.get().getResult().getStatus());
405 //verify(appcProviderLcm, times(1)).executeRequest(any());
408 doReturn(null).when(validationService).validateInput(any(), any(), any());
409 doReturn(null).when(evacuateInput).getActionIdentifiers();
410 results = appcProviderLcm.evacuate(evacuateInput);
411 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
412 Assert.assertTrue(303 == LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode());
413 //Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
414 // == results.get().getResult().getStatus().getCode());
415 //verify(appcProviderLcm, times(1)).executeRequest(any());
419 public void testSnapshot() throws Exception {
420 // Validation success
421 doReturn("Success").when(successlcmStatus).getMessage();
422 doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
423 doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
424 doReturn(null).when(validationService).validateInput(any(), any(), any());
426 SnapshotInput snapshotInput = mock(SnapshotInput.class);
427 doReturn(newCommonHeader("request-id-test")).when(snapshotInput).getCommonHeader();
428 doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
429 .when(snapshotInput).getActionIdentifiers();
431 Future<RpcResult<SnapshotOutput>> results = appcProviderLcm.snapshot(snapshotInput);
432 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
433 //Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
434 //verify(appcProviderLcm, times(1)).executeRequest(any());
437 doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
438 results = appcProviderLcm.snapshot(snapshotInput);
439 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
440 //Assert.assertEquals(failStatus, results.get().getResult().getStatus());
441 //verify(appcProviderLcm, times(1)).executeRequest(any());
444 doReturn(null).when(validationService).validateInput(any(), any(), any());
445 doReturn(null).when(snapshotInput).getActionIdentifiers();
446 results = appcProviderLcm.snapshot(snapshotInput);
447 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
448 Assert.assertTrue(303 == LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode());
449 //Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
450 // == results.get().getResult().getStatus().getCode());
451 //verify(appcProviderLcm, times(1)).executeRequest(any());
455 public void testRollback() throws Exception {
456 // Validation success
457 doReturn("Success").when(successlcmStatus).getMessage();
458 doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
459 doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
460 doReturn(null).when(validationService).validateInput(any(), any(), any());
462 RollbackInput rollbackInput = mock(RollbackInput.class);
463 doReturn(newCommonHeader("request-id-test")).when(rollbackInput).getCommonHeader();
464 doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
465 .when(rollbackInput).getActionIdentifiers();
467 Future<RpcResult<RollbackOutput>> results = appcProviderLcm.rollback(rollbackInput);
468 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
469 //Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
470 //verify(appcProviderLcm, times(1)).executeRequest(any());
473 doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
474 results = appcProviderLcm.rollback(rollbackInput);
475 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
476 //Assert.assertEquals(failStatus, results.get().getResult().getStatus());
477 //verify(appcProviderLcm, times(1)).executeRequest(any());
480 doReturn(null).when(validationService).validateInput(any(), any(), any());
481 doReturn(null).when(rollbackInput).getActionIdentifiers();
482 results = appcProviderLcm.rollback(rollbackInput);
483 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
484 Assert.assertTrue(303 == LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode());
485 //Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
486 // == results.get().getResult().getStatus().getCode());
487 //verify(appcProviderLcm, times(1)).executeRequest(any());
491 public void testSync() throws Exception {
492 // Validation success
493 doReturn("Success").when(successlcmStatus).getMessage();
494 doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
495 doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
496 doReturn(null).when(validationService).validateInput(any(), any(), any());
498 SyncInput syncInput = mock(SyncInput.class);
499 doReturn(newCommonHeader("request-id-test")).when(syncInput).getCommonHeader();
500 doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
501 .when(syncInput).getActionIdentifiers();
503 Future<RpcResult<SyncOutput>> results = appcProviderLcm.sync(syncInput);
504 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
505 //Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
506 //verify(appcProviderLcm, times(1)).executeRequest(any());
509 doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
510 results = appcProviderLcm.sync(syncInput);
511 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
512 //Assert.assertEquals(failStatus, results.get().getResult().getStatus());
513 //verify(appcProviderLcm, times(1)).executeRequest(any());
516 doReturn(null).when(validationService).validateInput(any(), any(), any());
517 doReturn(null).when(syncInput).getActionIdentifiers();
518 results = appcProviderLcm.sync(syncInput);
519 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
520 Assert.assertTrue(303 == LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode());
521 //Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
522 // == results.get().getResult().getStatus().getCode());
523 //verify(appcProviderLcm, times(1)).executeRequest(any());
527 public void testTerminate() throws Exception {
528 // Validation success
529 doReturn("Success").when(successlcmStatus).getMessage();
530 doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
531 doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
532 doReturn(null).when(validationService).validateInput(any(), any(), any());
534 TerminateInput terminateInput = mock(TerminateInput.class);
535 doReturn(newCommonHeader("request-id-test")).when(terminateInput).getCommonHeader();
536 doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
537 .when(terminateInput).getActionIdentifiers();
539 Future<RpcResult<TerminateOutput>> results = appcProviderLcm.terminate(terminateInput);
540 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
541 //Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
542 //verify(appcProviderLcm, times(1)).executeRequest(any());
545 doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
546 results = appcProviderLcm.terminate(terminateInput);
547 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
548 //Assert.assertEquals(failStatus, results.get().getResult().getStatus());
549 //verify(appcProviderLcm, times(1)).executeRequest(any());
552 doReturn(null).when(validationService).validateInput(any(), any(), any());
553 doReturn(null).when(terminateInput).getActionIdentifiers();
554 results = appcProviderLcm.terminate(terminateInput);
555 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
556 Assert.assertTrue(303 == LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode());
557 //Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
558 // == results.get().getResult().getStatus().getCode());
559 //verify(appcProviderLcm, times(1)).executeRequest(any());
563 public void testConfigure() throws Exception {
564 // Validation success
565 doReturn("Success").when(successlcmStatus).getMessage();
566 doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
567 doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
568 doReturn(null).when(validationService).validateInput(any(), any(), any());
570 ConfigureInput configureInput = mock(ConfigureInput.class);
571 doReturn(newCommonHeader("request-id-test")).when(configureInput).getCommonHeader();
572 doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
573 .when(configureInput).getActionIdentifiers();
575 Future<RpcResult<ConfigureOutput>> results = appcProviderLcm.configure(configureInput);
576 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
577 //Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
578 //verify(appcProviderLcm, times(1)).executeRequest(any());
581 doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
582 results = appcProviderLcm.configure(configureInput);
583 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
584 //Assert.assertEquals(failStatus, results.get().getResult().getStatus());
585 //verify(appcProviderLcm, times(1)).executeRequest(any());
588 doReturn(null).when(validationService).validateInput(any(), any(), any());
589 doReturn(null).when(configureInput).getActionIdentifiers();
590 results = appcProviderLcm.configure(configureInput);
591 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
592 Assert.assertTrue(303 == LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode());
593 //Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
594 // == results.get().getResult().getStatus().getCode());
595 //verify(appcProviderLcm, times(1)).executeRequest(any());
599 public void testConfigModify() throws Exception {
600 // Validation success
601 doReturn("Success").when(successlcmStatus).getMessage();
602 doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
603 doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
604 doReturn(null).when(validationService).validateInput(any(), any(), any());
606 ConfigModifyInput configModifyInput = mock(ConfigModifyInput.class);
607 doReturn(newCommonHeader("request-id-test")).when(configModifyInput).getCommonHeader();
608 doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
609 .when(configModifyInput).getActionIdentifiers();
611 Future<RpcResult<ConfigModifyOutput>> results = appcProviderLcm.configModify(configModifyInput);
612 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
613 //Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
614 //verify(appcProviderLcm, times(1)).executeRequest(any());
617 doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
618 results = appcProviderLcm.configModify(configModifyInput);
619 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
620 //Assert.assertEquals(failStatus, results.get().getResult().getStatus());
621 //verify(appcProviderLcm, times(1)).executeRequest(any());
624 doReturn(null).when(validationService).validateInput(any(), any(), any());
625 doReturn(null).when(configModifyInput).getActionIdentifiers();
626 results = appcProviderLcm.configModify(configModifyInput);
627 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
628 Assert.assertTrue(303 == LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode());
629 //Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
630 // == results.get().getResult().getStatus().getCode());
631 //verify(appcProviderLcm, times(1)).executeRequest(any());
635 public void testConfigScaleOut() throws Exception {
636 ConfigScaleOutInput mockInput = mock(ConfigScaleOutInput.class);
637 ConfigScaleOutOutput mockOutput = mock(ConfigScaleOutOutput.class);
638 ConfigScaleOutOutputBuilder mockOutputBuilder = mock(ConfigScaleOutOutputBuilder.class);
639 ConfigScaleOutService mockService = mock(ConfigScaleOutService.class);
641 when(mockService.process(mockInput)).thenReturn(mockOutputBuilder);
642 when(mockOutputBuilder.build()).thenReturn(mockOutput);
643 Future<RpcResult<ConfigScaleOutOutput>> results = appcProviderLcm.configScaleOut(mockInput);
644 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
648 public void testConfigRestore() throws Exception {
649 // Validation success
650 doReturn("Success").when(successlcmStatus).getMessage();
651 doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
652 doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
653 doReturn(null).when(validationService).validateInput(any(), any(), any());
655 ConfigRestoreInput configRestoreInput = mock(ConfigRestoreInput.class);
656 doReturn(newCommonHeader("request-id-test")).when(configRestoreInput).getCommonHeader();
657 doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
658 .when(configRestoreInput).getActionIdentifiers();
660 Future<RpcResult<ConfigRestoreOutput>> results = appcProviderLcm.configRestore(configRestoreInput);
661 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
662 //Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
663 //verify(appcProviderLcm, times(1)).executeRequest(any());
666 doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
667 results = appcProviderLcm.configRestore(configRestoreInput);
668 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
669 //Assert.assertEquals(failStatus, results.get().getResult().getStatus());
670 //verify(appcProviderLcm, times(1)).executeRequest(any());
673 doReturn(null).when(validationService).validateInput(any(), any(), any());
674 doReturn(null).when(configRestoreInput).getActionIdentifiers();
675 results = appcProviderLcm.configRestore(configRestoreInput);
676 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
677 Assert.assertTrue(303 == LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode());
678 //Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
679 // == results.get().getResult().getStatus().getCode());
680 //verify(appcProviderLcm, times(1)).executeRequest(any());
684 public void testTest() throws Exception {
685 // Validation success
686 doReturn("Success").when(successlcmStatus).getMessage();
687 doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
688 doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
689 doReturn(null).when(validationService).validateInput(any(), any(), any());
691 TestInput testInput = mock(TestInput.class);
692 doReturn(newCommonHeader("request-id-test")).when(testInput).getCommonHeader();
693 doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
694 .when(testInput).getActionIdentifiers();
696 Future<RpcResult<TestOutput>> results = appcProviderLcm.test(testInput);
697 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
698 //Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
699 //verify(appcProviderLcm, times(1)).executeRequest(any());
702 doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
703 results = appcProviderLcm.test(testInput);
704 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
705 //Assert.assertEquals(failStatus, results.get().getResult().getStatus());
706 //verify(appcProviderLcm, times(1)).executeRequest(any());
709 doReturn(null).when(validationService).validateInput(any(), any(), any());
710 doReturn(null).when(testInput).getActionIdentifiers();
711 results = appcProviderLcm.test(testInput);
712 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
713 Assert.assertTrue(303 == LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode());
714 //Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
715 // == results.get().getResult().getStatus().getCode());
716 //verify(appcProviderLcm, times(1)).executeRequest(any());
720 public void testStop() throws Exception {
721 // Validation success
722 doReturn("Success").when(successlcmStatus).getMessage();
723 doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
724 doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
725 doReturn(null).when(validationService).validateInput(any(), any(), any());
727 StopInput stopInput = mock(StopInput.class);
728 doReturn(newCommonHeader("request-id-stop")).when(stopInput).getCommonHeader();
729 doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
730 .when(stopInput).getActionIdentifiers();
732 Future<RpcResult<StopOutput>> results = appcProviderLcm.stop(stopInput);
733 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
734 //Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
735 //verify(appcProviderLcm, times(1)).executeRequest(any());
738 doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
739 results = appcProviderLcm.stop(stopInput);
740 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
741 //Assert.assertEquals(failStatus, results.get().getResult().getStatus());
742 //verify(appcProviderLcm, times(1)).executeRequest(any());
745 doReturn(null).when(validationService).validateInput(any(), any(), any());
746 doReturn(null).when(stopInput).getActionIdentifiers();
747 results = appcProviderLcm.stop(stopInput);
748 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
749 Assert.assertTrue(303 == LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode());
750 //Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
751 // == results.get().getResult().getStatus().getCode());
752 //verify(appcProviderLcm, times(1)).executeRequest(any());
756 public void testStart() throws Exception {
757 // Validation success
758 doReturn("Success").when(successlcmStatus).getMessage();
759 doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
760 doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
761 doReturn(null).when(validationService).validateInput(any(), any(), any());
763 StartInput startInput = mock(StartInput.class);
764 doReturn(newCommonHeader("request-id-start")).when(startInput).getCommonHeader();
765 doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
766 .when(startInput).getActionIdentifiers();
768 Future<RpcResult<StartOutput>> results = appcProviderLcm.start(startInput);
769 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
770 //Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
771 //verify(appcProviderLcm, times(1)).executeRequest(any());
774 doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
775 results = appcProviderLcm.start(startInput);
776 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
777 //Assert.assertEquals(failStatus, results.get().getResult().getStatus());
778 //verify(appcProviderLcm, times(1)).executeRequest(any());
781 doReturn(null).when(validationService).validateInput(any(), any(), any());
782 doReturn(null).when(startInput).getActionIdentifiers();
783 results = appcProviderLcm.start(startInput);
784 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
785 Assert.assertTrue(303 == LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode());
786 //Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
787 // == results.get().getResult().getStatus().getCode());
788 //verify(appcProviderLcm, times(1)).executeRequest(any());
792 public void testAudit() throws Exception {
793 // Validation success
794 doReturn("Success").when(successlcmStatus).getMessage();
795 doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
796 doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
797 doReturn(null).when(validationService).validateInput(any(), any(), any());
799 AuditInput auditInput = mock(AuditInput.class);
800 doReturn(newCommonHeader("request-id-aduit")).when(auditInput).getCommonHeader();
801 doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
802 .when(auditInput).getActionIdentifiers();
804 Future<RpcResult<AuditOutput>> results = appcProviderLcm.audit(auditInput);
805 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
806 //Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
807 //verify(appcProviderLcm, times(1)).executeRequest(any());
810 doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
811 results = appcProviderLcm.audit(auditInput);
812 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
813 //Assert.assertEquals(failStatus, results.get().getResult().getStatus());
814 //verify(appcProviderLcm, times(1)).executeRequest(any());
817 doReturn(null).when(validationService).validateInput(any(), any(), any());
818 doReturn(null).when(auditInput).getActionIdentifiers();
819 results = appcProviderLcm.audit(auditInput);
820 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
821 Assert.assertTrue(303 == LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode());
822 //Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
823 // == results.get().getResult().getStatus().getCode());
824 //verify(appcProviderLcm, times(1)).executeRequest(any());
828 public void testSoftwareUpload() throws Exception {
829 // Validation success
830 doReturn("Success").when(successlcmStatus).getMessage();
831 doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
832 doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
833 doReturn(null).when(validationService).validateInput(any(), any(), any());
835 SoftwareUploadInput softwareUploadInput = mock(SoftwareUploadInput.class);
836 doReturn(newCommonHeader("request-id-aduit")).when(softwareUploadInput).getCommonHeader();
837 doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
838 .when(softwareUploadInput).getActionIdentifiers();
840 Future<RpcResult<SoftwareUploadOutput>> results = appcProviderLcm.softwareUpload(softwareUploadInput);
841 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
842 //Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
843 //verify(appcProviderLcm, times(1)).executeRequest(any());
846 doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
847 results = appcProviderLcm.softwareUpload(softwareUploadInput);
848 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
849 //Assert.assertEquals(failStatus, results.get().getResult().getStatus());
850 //verify(appcProviderLcm, times(1)).executeRequest(any());
853 doReturn(null).when(validationService).validateInput(any(), any(), any());
854 doReturn(null).when(softwareUploadInput).getActionIdentifiers();
855 results = appcProviderLcm.softwareUpload(softwareUploadInput);
856 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
857 Assert.assertTrue(303 == LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode());
858 //Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
859 // == results.get().getResult().getStatus().getCode());
860 //verify(appcProviderLcm, times(1)).executeRequest(any());
864 public void testHealthCheck() throws Exception {
865 // Validation success
866 doReturn("Success").when(successlcmStatus).getMessage();
867 doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
868 doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
869 doReturn(null).when(validationService).validateInput(any(), any(), any());
871 HealthCheckInput healthCheckInput = mock(HealthCheckInput.class);
872 doReturn(newCommonHeader("request-id-aduit")).when(healthCheckInput).getCommonHeader();
873 doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
874 .when(healthCheckInput).getActionIdentifiers();
876 Future<RpcResult<HealthCheckOutput>> results = appcProviderLcm.healthCheck(healthCheckInput);
877 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
878 //Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
879 //verify(appcProviderLcm, times(1)).executeRequest(any());
882 doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
883 results = appcProviderLcm.healthCheck(healthCheckInput);
884 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
885 //Assert.assertEquals(failStatus, results.get().getResult().getStatus());
886 //verify(appcProviderLcm, times(1)).executeRequest(any());
889 doReturn(null).when(validationService).validateInput(any(), any(), any());
890 doReturn(null).when(healthCheckInput).getActionIdentifiers();
891 results = appcProviderLcm.healthCheck(healthCheckInput);
892 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
893 Assert.assertTrue(303 == LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode());
894 //Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
895 // == results.get().getResult().getStatus().getCode());
896 //verify(appcProviderLcm, times(1)).executeRequest(any());
900 public void testLiveUpgrade() throws Exception {
901 // Validation success
902 doReturn("Success").when(successlcmStatus).getMessage();
903 doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
904 doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
905 doReturn(null).when(validationService).validateInput(any(), any(), any());
907 LiveUpgradeInput liveUpgradeInput = mock(LiveUpgradeInput.class);
908 doReturn(newCommonHeader("request-id-aduit")).when(liveUpgradeInput).getCommonHeader();
909 doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
910 .when(liveUpgradeInput).getActionIdentifiers();
912 Future<RpcResult<LiveUpgradeOutput>> results = appcProviderLcm.liveUpgrade(liveUpgradeInput);
913 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
914 //Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
915 //verify(appcProviderLcm, times(1)).executeRequest(any());
918 doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
919 results = appcProviderLcm.liveUpgrade(liveUpgradeInput);
920 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
921 //Assert.assertEquals(failStatus, results.get().getResult().getStatus());
922 //verify(appcProviderLcm, times(1)).executeRequest(any());
925 doReturn(null).when(validationService).validateInput(any(), any(), any());
926 doReturn(null).when(liveUpgradeInput).getActionIdentifiers();
927 results = appcProviderLcm.liveUpgrade(liveUpgradeInput);
928 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
929 Assert.assertTrue(303 == LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode());
930 //Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
931 // == results.get().getResult().getStatus().getCode());
932 //verify(appcProviderLcm, times(1)).executeRequest(any());
936 public void testLock() throws Exception {
937 // Validation success
938 doReturn("Success").when(successlcmStatus).getMessage();
939 doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
940 doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
941 doReturn(null).when(validationService).validateInput(any(), any(), any());
943 LockInput lockInput = mock(LockInput.class);
944 doReturn(newCommonHeader("request-id-aduit")).when(lockInput).getCommonHeader();
945 doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
946 .when(lockInput).getActionIdentifiers();
948 Future<RpcResult<LockOutput>> results = appcProviderLcm.lock(lockInput);
949 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
950 //Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
951 //verify(appcProviderLcm, times(1)).executeRequest(any());
954 doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
955 results = appcProviderLcm.lock(lockInput);
956 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
957 //Assert.assertEquals(failStatus, results.get().getResult().getStatus());
958 //verify(appcProviderLcm, times(1)).executeRequest(any());
961 doReturn(null).when(validationService).validateInput(any(), any(), any());
962 doReturn(null).when(lockInput).getActionIdentifiers();
963 results = appcProviderLcm.lock(lockInput);
964 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
965 Assert.assertTrue(303 == LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode());
966 //Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
967 // == results.get().getResult().getStatus().getCode());
968 //verify(appcProviderLcm, times(1)).executeRequest(any());
972 public void testUnlock() throws Exception {
973 // Validation success
974 doReturn("Success").when(successlcmStatus).getMessage();
975 doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
976 doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
977 doReturn(null).when(validationService).validateInput(any(), any(), any());
979 UnlockInput unlockInput = mock(UnlockInput.class);
980 doReturn(newCommonHeader("request-id-aduit")).when(unlockInput).getCommonHeader();
981 doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
982 .when(unlockInput).getActionIdentifiers();
984 Future<RpcResult<UnlockOutput>> results = appcProviderLcm.unlock(unlockInput);
985 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
986 //Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
987 //verify(appcProviderLcm, times(1)).executeRequest(any());
990 doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
991 results = appcProviderLcm.unlock(unlockInput);
992 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
993 //Assert.assertEquals(failStatus, results.get().getResult().getStatus());
994 //verify(appcProviderLcm, times(1)).executeRequest(any());
997 doReturn(null).when(validationService).validateInput(any(), any(), any());
998 doReturn(null).when(unlockInput).getActionIdentifiers();
999 results = appcProviderLcm.unlock(unlockInput);
1000 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
1001 Assert.assertTrue(303 == LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode());
1002 //Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
1003 // == results.get().getResult().getStatus().getCode());
1004 //verify(appcProviderLcm, times(1)).executeRequest(any());
1008 public void testCheckLock() throws Exception {
1009 // Validation success
1010 doReturn("Success").when(successlcmStatus).getMessage();
1011 Map<String, String> additionalContext = new HashMap<>();
1012 additionalContext.put("locked", "true");
1013 doReturn(additionalContext).when(responseContext).getAdditionalContext();
1014 doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
1015 doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
1016 doReturn(null).when(validationService).validateInput(any(), any(), any());
1017 CheckLockInput checkLockInput = mock(CheckLockInput.class);
1018 doReturn(newCommonHeader("request-id-aduit")).when(checkLockInput).getCommonHeader();
1019 doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
1020 .when(checkLockInput).getActionIdentifiers();
1022 Future<RpcResult<CheckLockOutput>> results = appcProviderLcm.checkLock(checkLockInput);
1023 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
1024 //Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
1025 //verify(appcProviderLcm, times(1)).executeRequest(any());
1027 // Validation failed
1028 doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
1029 results = appcProviderLcm.checkLock(checkLockInput);
1030 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
1031 //Assert.assertEquals(failStatus, results.get().getResult().getStatus());
1032 //verify(appcProviderLcm, times(1)).executeRequest(any());
1035 doReturn(null).when(validationService).validateInput(any(), any(), any());
1036 doReturn(null).when(checkLockInput).getActionIdentifiers();
1037 results = appcProviderLcm.checkLock(checkLockInput);
1038 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
1039 Assert.assertTrue(303 == LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode());
1040 //Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
1041 // == results.get().getResult().getStatus().getCode());
1042 //verify(appcProviderLcm, times(1)).executeRequest(any());
1046 public void testConfigBackup() throws Exception {
1047 // Validation success
1048 doReturn("Success").when(successlcmStatus).getMessage();
1049 doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
1050 doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
1051 doReturn(null).when(validationService).validateInput(any(), any(), any());
1053 ConfigBackupInput configBackupInput = mock(ConfigBackupInput.class);
1054 doReturn(newCommonHeader("request-id-aduit")).when(configBackupInput).getCommonHeader();
1055 doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
1056 .when(configBackupInput).getActionIdentifiers();
1058 Future<RpcResult<ConfigBackupOutput>> results = appcProviderLcm.configBackup(configBackupInput);
1059 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
1060 //Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
1061 //verify(appcProviderLcm, times(1)).executeRequest(any());
1063 // Validation failed
1064 doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
1065 results = appcProviderLcm.configBackup(configBackupInput);
1066 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
1067 //Assert.assertEquals(failStatus, results.get().getResult().getStatus());
1068 //verify(appcProviderLcm, times(1)).executeRequest(any());
1071 doReturn(null).when(validationService).validateInput(any(), any(), any());
1072 doReturn(null).when(configBackupInput).getActionIdentifiers();
1073 results = appcProviderLcm.configBackup(configBackupInput);
1074 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
1075 Assert.assertTrue(303 == LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode());
1076 //Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
1077 // == results.get().getResult().getStatus().getCode());
1078 //verify(appcProviderLcm, times(1)).executeRequest(any());
1082 public void testConfigBackupDelete() throws Exception {
1083 // Validation success
1084 doReturn("Success").when(successlcmStatus).getMessage();
1085 doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
1086 doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
1087 doReturn(null).when(validationService).validateInput(any(), any(), any());
1089 ConfigBackupDeleteInput configBackupDeleteInput = mock(ConfigBackupDeleteInput.class);
1090 doReturn(newCommonHeader("request-id-aduit")).when(configBackupDeleteInput).getCommonHeader();
1091 doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
1092 .when(configBackupDeleteInput).getActionIdentifiers();
1094 Future<RpcResult<ConfigBackupDeleteOutput>> results = appcProviderLcm.configBackupDelete
1095 (configBackupDeleteInput);
1096 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
1097 //Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
1098 //verify(appcProviderLcm, times(1)).executeRequest(any());
1100 // Validation failed
1101 doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
1102 results = appcProviderLcm.configBackupDelete(configBackupDeleteInput);
1103 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
1104 //Assert.assertEquals(failStatus, results.get().getResult().getStatus());
1105 //verify(appcProviderLcm, times(1)).executeRequest(any());
1108 doReturn(null).when(validationService).validateInput(any(), any(), any());
1109 doReturn(null).when(configBackupDeleteInput).getActionIdentifiers();
1110 results = appcProviderLcm.configBackupDelete(configBackupDeleteInput);
1111 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
1112 Assert.assertTrue(303 == LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode());
1113 //Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
1114 // == results.get().getResult().getStatus().getCode());
1115 //verify(appcProviderLcm, times(1)).executeRequest(any());
1119 public void testConfigExport() throws Exception {
1120 // Validation success
1121 doReturn("Success").when(successlcmStatus).getMessage();
1122 doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
1123 doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
1124 doReturn(null).when(validationService).validateInput(any(), any(), any());
1126 ConfigExportInput configExportInput = mock(ConfigExportInput.class);
1127 doReturn(newCommonHeader("request-id-aduit")).when(configExportInput).getCommonHeader();
1128 doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
1129 .when(configExportInput).getActionIdentifiers();
1131 Future<RpcResult<ConfigExportOutput>> results = appcProviderLcm.configExport
1132 (configExportInput);
1133 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
1134 //Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
1135 //verify(appcProviderLcm, times(1)).executeRequest(any());
1137 // Validation failed
1138 doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
1139 results = appcProviderLcm.configExport(configExportInput);
1140 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
1141 //Assert.assertEquals(failStatus, results.get().getResult().getStatus());
1142 //verify(appcProviderLcm, times(1)).executeRequest(any());
1145 doReturn(null).when(validationService).validateInput(any(), any(), any());
1146 doReturn(null).when(configExportInput).getActionIdentifiers();
1147 results = appcProviderLcm.configExport(configExportInput);
1148 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
1149 Assert.assertTrue(303 == LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode());
1150 //Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
1151 // == results.get().getResult().getStatus().getCode());
1152 //verify(appcProviderLcm, times(1)).executeRequest(any());
1156 public void testStopApplication() throws Exception {
1157 // Validation success
1158 doReturn("Success").when(successlcmStatus).getMessage();
1159 doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
1160 doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
1161 doReturn(null).when(validationService).validateInput(any(), any(), any());
1163 StopApplicationInput stopApplicationInput = mock(StopApplicationInput.class);
1164 doReturn(newCommonHeader("request-id-aduit")).when(stopApplicationInput).getCommonHeader();
1165 doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
1166 .when(stopApplicationInput).getActionIdentifiers();
1168 Future<RpcResult<StopApplicationOutput>> results = appcProviderLcm.stopApplication
1169 (stopApplicationInput);
1170 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
1171 //Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
1172 //verify(appcProviderLcm, times(1)).executeRequest(any());
1174 // Validation failed
1175 doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
1176 results = appcProviderLcm.stopApplication(stopApplicationInput);
1177 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
1178 //Assert.assertEquals(failStatus, results.get().getResult().getStatus());
1179 //verify(appcProviderLcm, times(1)).executeRequest(any());
1182 doReturn(null).when(validationService).validateInput(any(), any(), any());
1183 doReturn(null).when(stopApplicationInput).getActionIdentifiers();
1184 results = appcProviderLcm.stopApplication(stopApplicationInput);
1185 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
1186 Assert.assertTrue(303 == LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode());
1187 //Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
1188 // == results.get().getResult().getStatus().getCode());
1189 //verify(appcProviderLcm, times(1)).executeRequest(any());
1193 public void testQuery() throws Exception {
1194 QueryInput mockInput = mock(QueryInput.class);
1195 QueryOutput mockOutput = mock(QueryOutput.class);
1196 QueryOutputBuilder mockQueryOutputBuilder = mock(QueryOutputBuilder.class);
1197 QueryService mockQuery = mock(QueryService.class);
1199 //whenNew(QueryService.class).withNoArguments().thenReturn(mockQuery);
1200 when(mockQuery.process(mockInput)).thenReturn(mockQueryOutputBuilder);
1201 when(mockQueryOutputBuilder.build()).thenReturn(mockOutput);
1203 Future<RpcResult<QueryOutput>> results = appcProviderLcm.query(mockInput);
1204 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
1205 //verify(mockQuery, times(1)).process(mockInput);
1206 //Assert.assertEquals("Should return mockOutput", mockOutput, results.get().getResult());
1210 public void testReboot() throws Exception {
1211 RebootInput mockInput = mock(RebootInput.class);
1212 RebootOutput mockOutput = mock(RebootOutput.class);
1213 RebootOutputBuilder mockRebootOutputBuilder = mock(RebootOutputBuilder.class);
1214 RebootService mockReboot = mock(RebootService.class);
1216 //whenNew(RebootService.class).withNoArguments().thenReturn(mockReboot);
1217 when(mockReboot.process(mockInput)).thenReturn(mockRebootOutputBuilder);
1218 when(mockRebootOutputBuilder.build()).thenReturn(mockOutput);
1220 Future<RpcResult<RebootOutput>> results = appcProviderLcm.reboot(mockInput);
1221 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
1222 //verify(mockReboot, times(1)).process(mockInput);
1223 //Assert.assertEquals("Should return mockOutput", mockOutput, results.get().getResult());
1227 public void testAttachVolume() throws Exception {
1228 AttachVolumeInput mockInput = mock(AttachVolumeInput.class);
1229 AttachVolumeOutput mockOutput = mock(AttachVolumeOutput.class);
1230 AttachVolumeOutputBuilder mockOutputBuilder = mock(AttachVolumeOutputBuilder.class);
1231 VolumeService mockVolumeService = mock(VolumeService.class);
1233 //whenNew(VolumeService.class).withArguments(true).thenReturn(mockVolumeService);
1234 when(mockVolumeService.attachVolume(mockInput)).thenReturn(mockOutputBuilder);
1235 when(mockOutputBuilder.build()).thenReturn(mockOutput);
1237 Future<RpcResult<AttachVolumeOutput>> results = appcProviderLcm.attachVolume(mockInput);
1238 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
1239 //verify(mockVolumeService, times(1)).attachVolume(mockInput);
1240 //Assert.assertEquals("Should return mockOutput", mockOutput, results.get().getResult());
1244 public void testDetachVolume() throws Exception {
1245 DetachVolumeInput mockInput = mock(DetachVolumeInput.class);
1246 DetachVolumeOutput mockOutput = mock(DetachVolumeOutput.class);
1247 DetachVolumeOutputBuilder mockOutputBuilder = mock(DetachVolumeOutputBuilder.class);
1248 VolumeService mockVolumeService = mock(VolumeService.class);
1250 //whenNew(VolumeService.class).withArguments(false).thenReturn(mockVolumeService);
1251 when(mockVolumeService.detachVolume(mockInput)).thenReturn(mockOutputBuilder);
1252 when(mockOutputBuilder.build()).thenReturn(mockOutput);
1254 Future<RpcResult<DetachVolumeOutput>> results = appcProviderLcm.detachVolume(mockInput);
1255 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
1256 //verify(mockVolumeService, times(1)).detachVolume(mockInput);
1257 //Assert.assertEquals("Should return mockOutput", mockOutput, results.get().getResult());
1261 public void testQuiesceTraffic() throws Exception {
1262 QuiesceTrafficInput mockInput = mock(QuiesceTrafficInput.class);
1263 QuiesceTrafficOutput mockOutput = mock(QuiesceTrafficOutput.class);
1264 QuiesceTrafficOutputBuilder mockOutputBuilder = mock(QuiesceTrafficOutputBuilder.class);
1265 QuiesceTrafficService mockService = mock(QuiesceTrafficService.class);
1267 //whenNew(QuiesceTrafficService.class).withNoArguments().thenReturn(mockService);
1268 when(mockService.process(mockInput)).thenReturn(mockOutputBuilder);
1269 when(mockOutputBuilder.build()).thenReturn(mockOutput);
1271 Future<RpcResult<QuiesceTrafficOutput>> results = appcProviderLcm.quiesceTraffic(mockInput);
1272 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
1273 //verify(mockService, times(1)).process(mockInput);
1274 //Assert.assertEquals("Should return mockOutput", mockOutput, results.get().getResult());
1278 public void testResumeTraffic() throws Exception {
1279 ResumeTrafficInput mockInput = mock(ResumeTrafficInput.class);
1280 ResumeTrafficOutput mockOutput = mock(ResumeTrafficOutput.class);
1281 ResumeTrafficOutputBuilder mockOutputBuilder = mock(ResumeTrafficOutputBuilder.class);
1282 ResumeTrafficService mockService = mock(ResumeTrafficService.class);
1284 //whenNew(ResumeTrafficService.class).withNoArguments().thenReturn(mockService);
1285 when(mockService.process(mockInput)).thenReturn(mockOutputBuilder);
1286 when(mockOutputBuilder.build()).thenReturn(mockOutput);
1288 Future<RpcResult<ResumeTrafficOutput>> results = appcProviderLcm.resumeTraffic(mockInput);
1289 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
1290 //verify(mockService, times(1)).process(mockInput);
1291 //Assert.assertEquals("Should return mockOutput", mockOutput, results.get().getResult());
1295 public void testUpgradePreCheck() throws Exception {
1296 UpgradePreCheckInput mockInput = mock(UpgradePreCheckInput.class);
1297 UpgradePreCheckOutput mockOutput = mock(UpgradePreCheckOutput.class);
1298 UpgradePreCheckOutputBuilder mockOutputBuilder = mock(UpgradePreCheckOutputBuilder.class);
1299 UpgradeService mockService = mock(UpgradeService.class);
1301 //whenNew(UpgradeService.class).withAnyArguments().thenReturn(mockService);
1302 when(mockService.upgradePreCheck(mockInput)).thenReturn(mockOutputBuilder);
1303 when(mockOutputBuilder.build()).thenReturn(mockOutput);
1305 Future<RpcResult<UpgradePreCheckOutput>> results = appcProviderLcm.upgradePreCheck(mockInput);
1306 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
1307 //verify(mockService, times(1)).upgradePreCheck(mockInput);
1308 //Assert.assertEquals("Should return mockOutput", mockOutput, results.get().getResult());
1313 public void testUpgradePostCheck() throws Exception {
1314 UpgradePostCheckInput mockInput = mock(UpgradePostCheckInput.class);
1315 UpgradePostCheckOutput mockOutput = mock(UpgradePostCheckOutput.class);
1316 UpgradePostCheckOutputBuilder mockOutputBuilder = mock(UpgradePostCheckOutputBuilder.class);
1317 UpgradeService mockService = mock(UpgradeService.class);
1319 //whenNew(UpgradeService.class).withAnyArguments().thenReturn(mockService);
1320 when(mockService.upgradePostCheck(mockInput)).thenReturn(mockOutputBuilder);
1321 when(mockOutputBuilder.build()).thenReturn(mockOutput);
1323 Future<RpcResult<UpgradePostCheckOutput>> results = appcProviderLcm.upgradePostCheck(mockInput);
1324 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
1325 //verify(mockService, times(1)).upgradePostCheck(mockInput);
1326 //Assert.assertEquals("Should return mockOutput", mockOutput, results.get().getResult());
1330 public void testUpgradeSoftware() throws Exception {
1331 UpgradeSoftwareInput mockInput = mock(UpgradeSoftwareInput.class);
1332 UpgradeSoftwareOutput mockOutput = mock(UpgradeSoftwareOutput.class);
1333 UpgradeSoftwareOutputBuilder mockOutputBuilder = mock(UpgradeSoftwareOutputBuilder.class);
1334 UpgradeService mockService = mock(UpgradeService.class);
1336 //whenNew(UpgradeService.class).withAnyArguments().thenReturn(mockService);
1337 when(mockService.upgradeSoftware(mockInput)).thenReturn(mockOutputBuilder);
1338 when(mockOutputBuilder.build()).thenReturn(mockOutput);
1340 Future<RpcResult<UpgradeSoftwareOutput>> results = appcProviderLcm.upgradeSoftware(mockInput);
1341 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
1342 //verify(mockService, times(1)).upgradeSoftware(mockInput);
1343 //Assert.assertEquals("Should return mockOutput", mockOutput, results.get().getResult());
1347 public void testUpgradeBackup() throws Exception {
1348 UpgradeBackupInput mockInput = mock(UpgradeBackupInput.class);
1349 UpgradeBackupOutput mockOutput = mock(UpgradeBackupOutput.class);
1350 UpgradeBackupOutputBuilder mockOutputBuilder = mock(UpgradeBackupOutputBuilder.class);
1351 UpgradeService mockService = mock(UpgradeService.class);
1353 //whenNew(UpgradeService.class).withAnyArguments().thenReturn(mockService);
1354 when(mockService.upgradeBackup(mockInput)).thenReturn(mockOutputBuilder);
1355 when(mockOutputBuilder.build()).thenReturn(mockOutput);
1357 Future<RpcResult<UpgradeBackupOutput>> results = appcProviderLcm.upgradeBackup(mockInput);
1358 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
1359 //verify(mockService, times(1)).upgradeBackup(mockInput);
1360 //Assert.assertEquals("Should return mockOutput", mockOutput, results.get().getResult());
1364 public void testUpgradeBackout() throws Exception {
1365 UpgradeBackoutInput mockInput = mock(UpgradeBackoutInput.class);
1366 UpgradeBackoutOutput mockOutput = mock(UpgradeBackoutOutput.class);
1367 UpgradeBackoutOutputBuilder mockOutputBuilder = mock(UpgradeBackoutOutputBuilder.class);
1368 UpgradeService mockService = mock(UpgradeService.class);
1370 //whenNew(UpgradeService.class).withAnyArguments().thenReturn(mockService);
1371 when(mockService.upgradeBackout(mockInput)).thenReturn(mockOutputBuilder);
1372 when(mockOutputBuilder.build()).thenReturn(mockOutput);
1374 Future<RpcResult<UpgradeBackoutOutput>> results = appcProviderLcm.upgradeBackout(mockInput);
1375 Assert.assertTrue(302 == results.get().getResult().getStatus().getCode());
1376 //verify(mockService, times(1)).upgradeBackout(mockInput);
1377 //Assert.assertEquals("Should return mockOutput", mockOutput, results.get().getResult());
1381 public void testTimestampFormatShort() throws Exception {
1382 // Validation success
1383 doReturn("Success").when(successlcmStatus).getMessage();
1384 doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
1385 doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
1386 doReturn(null).when(validationService).validateInput(any(), any(), any());
1388 ConfigExportInput configExportInput = mock(ConfigExportInput.class);
1389 long epochWithZeroFractionalSeconds = 1529495219000l;
1390 doReturn(newCommonHeader("request-id-aduit", epochWithZeroFractionalSeconds)).when(configExportInput).getCommonHeader();
1391 doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
1392 .when(configExportInput).getActionIdentifiers();
1394 Future<RpcResult<ConfigExportOutput>> results = appcProviderLcm.configExport
1395 (configExportInput);
1396 Assert.assertEquals(302, (int)results.get().getResult().getStatus().getCode());
1399 private ActionIdentifiers newActionIdentifier(String vnfId, String vnfcId, String vserverId) {
1400 ActionIdentifiersBuilder actionIdentifiersBuilder = new ActionIdentifiersBuilder();
1401 actionIdentifiersBuilder.setVnfId(vnfId);
1402 actionIdentifiersBuilder.setVnfcName(vnfcId);
1403 actionIdentifiersBuilder.setVserverId(vserverId);
1404 return actionIdentifiersBuilder.build();
1407 private CommonHeader newCommonHeader(String requestId) {
1408 return newCommonHeader(requestId, System.currentTimeMillis());
1411 private CommonHeader newCommonHeader(String requestId, long epoch) {
1412 CommonHeaderBuilder commonHeaderBuilder = new CommonHeaderBuilder();
1413 commonHeaderBuilder.setRequestId(requestId);
1414 commonHeaderBuilder.setApiVer("2.0.0");
1415 commonHeaderBuilder.setOriginatorId("originatortest");
1416 DateFormat ZULU_FORMATTER = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SS'Z'");
1417 ZULU_FORMATTER.setTimeZone(TimeZone.getTimeZone("UTC"));
1418 commonHeaderBuilder.setTimestamp(ZULU.getDefaultInstance(ZULU_FORMATTER.format(epoch)));
1419 return commonHeaderBuilder.build();