2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017 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 * ECOMP is a trademark and service mark of AT&T Intellectual Property.
22 * ============LICENSE_END=========================================================
25 package org.onap.appc.provider.lcm.service;
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.Mockito;
32 import org.mockito.internal.util.reflection.Whitebox;
33 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.Action;
34 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AttachVolumeInput;
35 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AttachVolumeOutputBuilder;
36 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.DetachVolumeInput;
37 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.DetachVolumeOutputBuilder;
38 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.Payload;
39 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ZULU;
40 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.action.identifiers.ActionIdentifiers;
41 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.common.header.CommonHeader;
42 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.status.Status;
43 import org.onap.appc.domainmodel.lcm.ResponseContext;
44 import org.onap.appc.executor.objects.LCMCommandStatus;
45 import org.onap.appc.requesthandler.objects.RequestHandlerOutput;
46 import org.powermock.core.classloader.annotations.PrepareForTest;
47 import org.powermock.modules.junit4.PowerMockRunner;
49 import static org.mockito.Matchers.any;
50 import static org.mockito.Mockito.mock;
51 import static org.mockito.Mockito.spy;
52 import static org.mockito.Mockito.times;
53 import static org.powermock.api.mockito.PowerMockito.whenNew;
55 @RunWith(PowerMockRunner.class)
56 @PrepareForTest({VolumeService.class, RequestExecutor.class})
57 public class VolumeServiceTest {
58 private final String PAYLOAD_STRING = "{\"A\":\"A-value\",\"B\":{\"C\":\"B.C-value\",\"D\":\"B.D-value\"}}";
59 private AttachVolumeInput mockAttachInput = mock(AttachVolumeInput.class);
60 private DetachVolumeInput mockDetachInput = mock(DetachVolumeInput.class);
61 private CommonHeader mockCommonHeader = mock(CommonHeader.class);
62 private ActionIdentifiers mockAI = mock(ActionIdentifiers.class);
63 private Payload mockPayload = mock(Payload.class);
65 private VolumeService volumeServiceForAttachAction;
66 private VolumeService volumeServiceForDetachAction;
69 public void setUp() throws Exception {
70 volumeServiceForAttachAction = spy(new VolumeService(true));
71 volumeServiceForDetachAction = spy(new VolumeService(false));
75 public void testConstructor() throws Exception {
76 Action expectedAction = Action.AttachVolume;
77 Assert.assertEquals("Should have proper ACTION", expectedAction,
78 (Action) org.powermock.reflect.Whitebox.getInternalState(volumeServiceForAttachAction, "expectedAction"));
79 Assert.assertEquals("Should have attach-volume RPC name", "attach-volume",
80 (org.powermock.reflect.Whitebox.getInternalState(volumeServiceForAttachAction, "rpcName")).toString());
82 expectedAction = Action.DetachVolume;
83 Assert.assertEquals("Should have proper ACTION", expectedAction,
84 (Action) org.powermock.reflect.Whitebox.getInternalState(volumeServiceForDetachAction, "expectedAction"));
85 Assert.assertEquals("Should have detach-volume RPC name","detach-volume",
86 (org.powermock.reflect.Whitebox.getInternalState(volumeServiceForDetachAction, "rpcName")).toString());
90 // public void testAttachVolume() throws Exception {
91 // // test error occurs in validation
92 // AttachVolumeOutputBuilder outputBuilder = volumeServiceForAttachAction.attachVolume(mockAttachInput);
93 // Mockito.verify(volumeServiceForAttachAction, times(0)).proceedAction(any(), any(), any());
94 // Assert.assertTrue("Should not have commonHeader as we did not mock it",
95 // outputBuilder.getCommonHeader() == null);
96 // Assert.assertEquals("should return missing parameter status",
97 // Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()),
98 // outputBuilder.getStatus().getCode());
100 // // make validation pass
101 // Mockito.doReturn(mockCommonHeader).when(mockAttachInput).getCommonHeader();
102 // Mockito.doReturn(mockPayload).when(mockAttachInput).getPayload();
103 // Mockito.doReturn(PAYLOAD_STRING).when(mockPayload).getValue();
105 // ZULU zuluTimeStamp = new ZULU("2017-06-29T21:44:00.35Z");
106 // Mockito.doReturn(zuluTimeStamp).when(mockCommonHeader).getTimestamp();
107 // Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
108 // Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
109 // Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
111 // Mockito.doReturn(Action.AttachVolume).when(mockAttachInput).getAction();
112 // Mockito.doReturn(mockAI).when(mockAttachInput).getActionIdentifiers();
113 // Mockito.doReturn("vserverId").when(mockAI).getVserverId();
115 // test proceedAction return with error
116 // outputBuilder = volumeServiceForAttachAction.attachVolume(mockAttachInput);
117 // Mockito.verify(volumeServiceForAttachAction, times(1)).proceedAction(any(), any(), any());
118 // Assert.assertTrue("Should have commonHeader",
119 // outputBuilder.getCommonHeader() != null);
120 // Assert.assertEquals("should return rejected status",
121 // Integer.valueOf(LCMCommandStatus.REJECTED.getResponseCode()),
122 // outputBuilder.getStatus().getCode());
124 // test proceedAction return without error
125 // RequestExecutor mockExecutor = mock(RequestExecutor.class);
126 // whenNew(RequestExecutor.class).withNoArguments().thenReturn(mockExecutor);
128 // RequestHandlerOutput mockOutput = mock(RequestHandlerOutput.class);
129 // Mockito.doReturn(mockOutput).when(mockExecutor).executeRequest(any());
131 // ResponseContext mockResponseContext = mock(ResponseContext.class);
132 // Mockito.doReturn(mockResponseContext).when(mockOutput).getResponseContext();
134 // org.onap.appc.domainmodel.lcm.Status mockStatus = mock(org.onap.appc.domainmodel.lcm.Status.class);
135 // Integer successCode = Integer.valueOf(LCMCommandStatus.SUCCESS.getResponseCode());
136 // Mockito.doReturn(successCode).when(mockStatus).getCode();
137 // Mockito.doReturn(mockStatus).when(mockResponseContext).getStatus();
139 // outputBuilder = volumeServiceForAttachAction.attachVolume(mockAttachInput);
140 // Assert.assertTrue("Should have commonHeader",
141 // outputBuilder.getCommonHeader() != null);
142 // Assert.assertEquals("should return success status",
143 // successCode, outputBuilder.getStatus().getCode());
147 // public void testDetachVolumn() throws Exception {
148 // // test error occurs in validation
149 // DetachVolumeOutputBuilder outputBuilder = volumeServiceForDetachAction.detachVolume(mockDetachInput);
150 // Mockito.verify(volumeServiceForDetachAction, times(0)).proceedAction(any(), any(), any());
151 // Assert.assertTrue("Should not have commonHeader as we did not mock it",
152 // outputBuilder.getCommonHeader() == null);
153 // Assert.assertEquals("should return missing parameter status",
154 // Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()),
155 // outputBuilder.getStatus().getCode());
157 // // make validation pass
158 // Mockito.doReturn(mockCommonHeader).when(mockDetachInput).getCommonHeader();
159 // Mockito.doReturn(mockPayload).when(mockDetachInput).getPayload();
160 // Mockito.doReturn(PAYLOAD_STRING).when(mockPayload).getValue();
162 // ZULU zuluTimeStamp = new ZULU("2017-06-29T21:44:00.35Z");
163 // Mockito.doReturn(zuluTimeStamp).when(mockCommonHeader).getTimestamp();
164 // Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
165 // Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
166 // Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
168 // Mockito.doReturn(Action.DetachVolume).when(mockDetachInput).getAction();
169 // Mockito.doReturn(mockAI).when(mockDetachInput).getActionIdentifiers();
170 // Mockito.doReturn("vserverId").when(mockAI).getVserverId();
172 // test proceedAction return with error
173 // outputBuilder = volumeServiceForDetachAction.detachVolume(mockDetachInput);
174 // Mockito.verify(volumeServiceForDetachAction, times(1)).proceedAction(any(), any(), any());
175 // Assert.assertTrue("Should have commonHeader",
176 // outputBuilder.getCommonHeader() != null);
177 // Assert.assertEquals("should return rejected status",
178 // Integer.valueOf(LCMCommandStatus.REJECTED.getResponseCode()),
179 // outputBuilder.getStatus().getCode());
181 // test proceedAction return without error
182 // RequestExecutor mockExecutor = mock(RequestExecutor.class);
183 // whenNew(RequestExecutor.class).withNoArguments().thenReturn(mockExecutor);
185 // RequestHandlerOutput mockOutput = mock(RequestHandlerOutput.class);
186 // Mockito.doReturn(mockOutput).when(mockExecutor).executeRequest(any());
188 // ResponseContext mockResponseContext = mock(ResponseContext.class);
189 // Mockito.doReturn(mockResponseContext).when(mockOutput).getResponseContext();
191 // org.onap.appc.domainmodel.lcm.Status mockStatus = mock(org.onap.appc.domainmodel.lcm.Status.class);
192 // Integer successCode = Integer.valueOf(LCMCommandStatus.SUCCESS.getResponseCode());
193 // Mockito.doReturn(successCode).when(mockStatus).getCode();
194 // Mockito.doReturn(mockStatus).when(mockResponseContext).getStatus();;
196 // outputBuilder = volumeServiceForDetachAction.detachVolume(mockDetachInput);
197 // Assert.assertTrue("Should have commonHeader",
198 // outputBuilder.getCommonHeader() != null);
199 // Assert.assertEquals("should return success status",
200 // successCode, outputBuilder.getStatus().getCode());
204 public void testValidateForAttachAction() throws Exception {
205 // test commonHeader error
206 volumeServiceForAttachAction.validate(mockCommonHeader, Action.AttachVolume, mockAI, mockPayload);
207 Status status = (Status) Whitebox.getInternalState(volumeServiceForAttachAction, "status");
208 Assert.assertEquals("should return missing parameter",
209 Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
210 Mockito.verify(volumeServiceForDetachAction, times(0)).buildStatusForParamName(any(), any());
211 Mockito.verify(volumeServiceForDetachAction, times(0)).buildStatusForErrorMsg(any(), any());
213 ZULU mockTimeStamp = mock(ZULU.class);
214 Mockito.doReturn(mockTimeStamp).when(mockCommonHeader).getTimestamp();
215 Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
216 Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
217 Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
219 // test Invalid action
220 volumeServiceForAttachAction.validate(mockCommonHeader, Action.DetachVolume, mockAI, mockPayload);
221 status = (Status) Whitebox.getInternalState(volumeServiceForAttachAction, "status");
222 Assert.assertEquals("Should return invalid parameter for action",
223 Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()), status.getCode());
225 // test empty ActionIdentifier
226 volumeServiceForAttachAction.validate(mockCommonHeader, Action.AttachVolume, mockAI, mockPayload);
227 status = (Status) Whitebox.getInternalState(volumeServiceForAttachAction, "status");
228 Assert.assertEquals("should return missing parameter",
229 Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
231 // test empty VSERVER_ID
232 Mockito.doReturn("").when(mockAI).getVserverId();
233 volumeServiceForAttachAction.validate(mockCommonHeader, Action.AttachVolume, mockAI, mockPayload);
234 status = (Status) Whitebox.getInternalState(volumeServiceForAttachAction, "status");
235 Assert.assertEquals("should return invalid parameter",
236 Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()), status.getCode());
238 Mockito.doReturn("vserverId").when(mockAI).getVserverId();
241 volumeServiceForAttachAction.validate(mockCommonHeader, Action.AttachVolume, mockAI, null);
242 Mockito.verify(volumeServiceForAttachAction, times(1)).validateExcludedActIds(any(), any());
243 status = (Status) Whitebox.getInternalState(volumeServiceForAttachAction, "status");
244 Assert.assertEquals("should return missing parameter",
245 Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
247 // test empty payload
248 Mockito.doReturn("").when(mockPayload).getValue();
249 volumeServiceForAttachAction.validate(mockCommonHeader, Action.AttachVolume, mockAI, mockPayload);
250 status = (Status) Whitebox.getInternalState(volumeServiceForAttachAction, "status");
251 Assert.assertEquals("should return invalid parameter",
252 Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()), status.getCode());
254 // test space payload
255 Mockito.doReturn(" ").when(mockPayload).getValue();
256 volumeServiceForAttachAction.validate(mockCommonHeader, Action.AttachVolume, mockAI, mockPayload);
257 status = (Status) Whitebox.getInternalState(volumeServiceForAttachAction, "status");
258 Assert.assertEquals("should return invalid parameter",
259 Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()), status.getCode());
263 public void testValidateForDetachAction() throws Exception {
264 // test commonHeader error
265 volumeServiceForDetachAction.validate(mockCommonHeader, Action.DetachVolume, mockAI, mockPayload);
266 Status status = (Status) Whitebox.getInternalState(volumeServiceForDetachAction, "status");
267 Assert.assertEquals("should return missing parameter",
268 Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
269 Mockito.verify(volumeServiceForDetachAction, times(0)).buildStatusForParamName(any(), any());
270 Mockito.verify(volumeServiceForDetachAction, times(0)).buildStatusForErrorMsg(any(), any());
272 ZULU mockTimeStamp = mock(ZULU.class);
273 Mockito.doReturn(mockTimeStamp).when(mockCommonHeader).getTimestamp();
274 Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
275 Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
276 Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
278 // test Invalid action
279 volumeServiceForDetachAction.validate(mockCommonHeader, Action.AttachVolume, mockAI, mockPayload);
280 status = (Status) Whitebox.getInternalState(volumeServiceForDetachAction, "status");
281 Assert.assertEquals("Should return invalid parameter for action",
282 Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()), status.getCode());
284 // test empty ActionIdentifier
285 volumeServiceForDetachAction.validate(mockCommonHeader, Action.DetachVolume, mockAI, mockPayload);
286 status = (Status) Whitebox.getInternalState(volumeServiceForDetachAction, "status");
287 Assert.assertEquals("should return missing parameter",
288 Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
290 // test empty VSERVER_ID
291 Mockito.doReturn("").when(mockAI).getVserverId();
292 volumeServiceForDetachAction.validate(mockCommonHeader, Action.DetachVolume, mockAI, mockPayload);
293 status = (Status) Whitebox.getInternalState(volumeServiceForDetachAction, "status");
294 Assert.assertEquals("should return invalid parameter",
295 Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()), status.getCode());
297 Mockito.doReturn("vserverId").when(mockAI).getVserverId();
300 volumeServiceForDetachAction.validate(mockCommonHeader, Action.DetachVolume, mockAI, null);
301 Mockito.verify(volumeServiceForDetachAction, times(1)).validateExcludedActIds(any(), any());
302 status = (Status) Whitebox.getInternalState(volumeServiceForDetachAction, "status");
303 Assert.assertEquals("should return missing parameter",
304 Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
306 // test empty payload
307 Mockito.doReturn("").when(mockPayload).getValue();
308 volumeServiceForDetachAction.validate(mockCommonHeader, Action.DetachVolume, mockAI, mockPayload);
309 status = (Status) Whitebox.getInternalState(volumeServiceForDetachAction, "status");
310 Assert.assertEquals("should return invalid parameter",
311 Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()), status.getCode());
313 // test space payload
314 Mockito.doReturn(" ").when(mockPayload).getValue();
315 volumeServiceForDetachAction.validate(mockCommonHeader, Action.DetachVolume, mockAI, mockPayload);
316 status = (Status) Whitebox.getInternalState(volumeServiceForDetachAction, "status");
317 Assert.assertEquals("should return invalid parameter",
318 Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()), status.getCode());