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.lcm.service;
26 import org.junit.Assert;
27 import org.junit.Before;
28 import org.junit.Test;
29 import org.junit.runner.RunWith;
30 import org.mockito.Mockito;
31 import org.mockito.internal.util.reflection.Whitebox;
32 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.Action;
33 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AttachVolumeInput;
34 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AttachVolumeOutputBuilder;
35 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.DetachVolumeInput;
36 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.DetachVolumeOutputBuilder;
37 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.Payload;
38 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ZULU;
39 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.action.identifiers.ActionIdentifiers;
40 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.common.header.CommonHeader;
41 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.status.Status;
42 import org.onap.appc.domainmodel.lcm.ResponseContext;
43 import org.onap.appc.executor.objects.LCMCommandStatus;
44 import org.onap.appc.requesthandler.objects.RequestHandlerOutput;
45 import org.powermock.core.classloader.annotations.PrepareForTest;
46 import org.powermock.modules.junit4.PowerMockRunner;
48 import static org.mockito.Matchers.any;
49 import static org.mockito.Mockito.mock;
50 import static org.mockito.Mockito.spy;
51 import static org.mockito.Mockito.times;
52 import static org.powermock.api.mockito.PowerMockito.whenNew;
54 @RunWith(PowerMockRunner.class)
55 @PrepareForTest({VolumeService.class, RequestExecutor.class})
56 public class VolumeServiceTest {
57 private final String PAYLOAD_STRING = "{\"A\":\"A-value\",\"B\":{\"C\":\"B.C-value\",\"D\":\"B.D-value\"}}";
58 private AttachVolumeInput mockAttachInput = mock(AttachVolumeInput.class);
59 private DetachVolumeInput mockDetachInput = mock(DetachVolumeInput.class);
60 private CommonHeader mockCommonHeader = mock(CommonHeader.class);
61 private ActionIdentifiers mockAI = mock(ActionIdentifiers.class);
62 private Payload mockPayload = mock(Payload.class);
64 private VolumeService volumeServiceForAttachAction;
65 private VolumeService volumeServiceForDetachAction;
68 public void setUp() throws Exception {
69 volumeServiceForAttachAction = spy(new VolumeService(true));
70 volumeServiceForDetachAction = spy(new VolumeService(false));
74 public void testConstructor() throws Exception {
75 Action expectedAction = Action.AttachVolume;
76 Assert.assertEquals("Should have proper ACTION", expectedAction,
77 (Action) org.powermock.reflect.Whitebox.getInternalState(volumeServiceForAttachAction, "expectedAction"));
78 Assert.assertEquals("Should have attach-volume RPC name", "attach-volume",
79 (org.powermock.reflect.Whitebox.getInternalState(volumeServiceForAttachAction, "rpcName")).toString());
81 expectedAction = Action.DetachVolume;
82 Assert.assertEquals("Should have proper ACTION", expectedAction,
83 (Action) org.powermock.reflect.Whitebox.getInternalState(volumeServiceForDetachAction, "expectedAction"));
84 Assert.assertEquals("Should have detach-volume RPC name","detach-volume",
85 (org.powermock.reflect.Whitebox.getInternalState(volumeServiceForDetachAction, "rpcName")).toString());
89 // public void testAttachVolume() throws Exception {
90 // // test error occurs in validation
91 // AttachVolumeOutputBuilder outputBuilder = volumeServiceForAttachAction.attachVolume(mockAttachInput);
92 // Mockito.verify(volumeServiceForAttachAction, times(0)).proceedAction(any(), any(), any());
93 // Assert.assertTrue("Should not have commonHeader as we did not mock it",
94 // outputBuilder.getCommonHeader() == null);
95 // Assert.assertEquals("should return missing parameter status",
96 // Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()),
97 // outputBuilder.getStatus().getCode());
99 // // make validation pass
100 // Mockito.doReturn(mockCommonHeader).when(mockAttachInput).getCommonHeader();
101 // Mockito.doReturn(mockPayload).when(mockAttachInput).getPayload();
102 // Mockito.doReturn(PAYLOAD_STRING).when(mockPayload).getValue();
104 // ZULU zuluTimeStamp = new ZULU("2017-06-29T21:44:00.35Z");
105 // Mockito.doReturn(zuluTimeStamp).when(mockCommonHeader).getTimestamp();
106 // Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
107 // Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
108 // Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
110 // Mockito.doReturn(Action.AttachVolume).when(mockAttachInput).getAction();
111 // Mockito.doReturn(mockAI).when(mockAttachInput).getActionIdentifiers();
112 // Mockito.doReturn("vserverId").when(mockAI).getVserverId();
114 // test proceedAction return with error
115 // outputBuilder = volumeServiceForAttachAction.attachVolume(mockAttachInput);
116 // Mockito.verify(volumeServiceForAttachAction, times(1)).proceedAction(any(), any(), any());
117 // Assert.assertTrue("Should have commonHeader",
118 // outputBuilder.getCommonHeader() != null);
119 // Assert.assertEquals("should return rejected status",
120 // Integer.valueOf(LCMCommandStatus.REJECTED.getResponseCode()),
121 // outputBuilder.getStatus().getCode());
123 // test proceedAction return without error
124 // RequestExecutor mockExecutor = mock(RequestExecutor.class);
125 // whenNew(RequestExecutor.class).withNoArguments().thenReturn(mockExecutor);
127 // RequestHandlerOutput mockOutput = mock(RequestHandlerOutput.class);
128 // Mockito.doReturn(mockOutput).when(mockExecutor).executeRequest(any());
130 // ResponseContext mockResponseContext = mock(ResponseContext.class);
131 // Mockito.doReturn(mockResponseContext).when(mockOutput).getResponseContext();
133 // org.onap.appc.domainmodel.lcm.Status mockStatus = mock(org.onap.appc.domainmodel.lcm.Status.class);
134 // Integer successCode = Integer.valueOf(LCMCommandStatus.SUCCESS.getResponseCode());
135 // Mockito.doReturn(successCode).when(mockStatus).getCode();
136 // Mockito.doReturn(mockStatus).when(mockResponseContext).getStatus();
138 // outputBuilder = volumeServiceForAttachAction.attachVolume(mockAttachInput);
139 // Assert.assertTrue("Should have commonHeader",
140 // outputBuilder.getCommonHeader() != null);
141 // Assert.assertEquals("should return success status",
142 // successCode, outputBuilder.getStatus().getCode());
146 // public void testDetachVolumn() throws Exception {
147 // // test error occurs in validation
148 // DetachVolumeOutputBuilder outputBuilder = volumeServiceForDetachAction.detachVolume(mockDetachInput);
149 // Mockito.verify(volumeServiceForDetachAction, times(0)).proceedAction(any(), any(), any());
150 // Assert.assertTrue("Should not have commonHeader as we did not mock it",
151 // outputBuilder.getCommonHeader() == null);
152 // Assert.assertEquals("should return missing parameter status",
153 // Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()),
154 // outputBuilder.getStatus().getCode());
156 // // make validation pass
157 // Mockito.doReturn(mockCommonHeader).when(mockDetachInput).getCommonHeader();
158 // Mockito.doReturn(mockPayload).when(mockDetachInput).getPayload();
159 // Mockito.doReturn(PAYLOAD_STRING).when(mockPayload).getValue();
161 // ZULU zuluTimeStamp = new ZULU("2017-06-29T21:44:00.35Z");
162 // Mockito.doReturn(zuluTimeStamp).when(mockCommonHeader).getTimestamp();
163 // Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
164 // Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
165 // Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
167 // Mockito.doReturn(Action.DetachVolume).when(mockDetachInput).getAction();
168 // Mockito.doReturn(mockAI).when(mockDetachInput).getActionIdentifiers();
169 // Mockito.doReturn("vserverId").when(mockAI).getVserverId();
171 // test proceedAction return with error
172 // outputBuilder = volumeServiceForDetachAction.detachVolume(mockDetachInput);
173 // Mockito.verify(volumeServiceForDetachAction, times(1)).proceedAction(any(), any(), any());
174 // Assert.assertTrue("Should have commonHeader",
175 // outputBuilder.getCommonHeader() != null);
176 // Assert.assertEquals("should return rejected status",
177 // Integer.valueOf(LCMCommandStatus.REJECTED.getResponseCode()),
178 // outputBuilder.getStatus().getCode());
180 // test proceedAction return without error
181 // RequestExecutor mockExecutor = mock(RequestExecutor.class);
182 // whenNew(RequestExecutor.class).withNoArguments().thenReturn(mockExecutor);
184 // RequestHandlerOutput mockOutput = mock(RequestHandlerOutput.class);
185 // Mockito.doReturn(mockOutput).when(mockExecutor).executeRequest(any());
187 // ResponseContext mockResponseContext = mock(ResponseContext.class);
188 // Mockito.doReturn(mockResponseContext).when(mockOutput).getResponseContext();
190 // org.onap.appc.domainmodel.lcm.Status mockStatus = mock(org.onap.appc.domainmodel.lcm.Status.class);
191 // Integer successCode = Integer.valueOf(LCMCommandStatus.SUCCESS.getResponseCode());
192 // Mockito.doReturn(successCode).when(mockStatus).getCode();
193 // Mockito.doReturn(mockStatus).when(mockResponseContext).getStatus();;
195 // outputBuilder = volumeServiceForDetachAction.detachVolume(mockDetachInput);
196 // Assert.assertTrue("Should have commonHeader",
197 // outputBuilder.getCommonHeader() != null);
198 // Assert.assertEquals("should return success status",
199 // successCode, outputBuilder.getStatus().getCode());
203 public void testValidateForAttachAction() throws Exception {
204 // test commonHeader error
205 volumeServiceForAttachAction.validate(mockCommonHeader, Action.AttachVolume, mockAI, mockPayload);
206 Status status = (Status) Whitebox.getInternalState(volumeServiceForAttachAction, "status");
207 Assert.assertEquals("should return missing parameter",
208 Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
209 Mockito.verify(volumeServiceForDetachAction, times(0)).buildStatusForParamName(any(), any());
210 Mockito.verify(volumeServiceForDetachAction, times(0)).buildStatusForErrorMsg(any(), any());
212 ZULU mockTimeStamp = mock(ZULU.class);
213 Mockito.doReturn(mockTimeStamp).when(mockCommonHeader).getTimestamp();
214 Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
215 Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
216 Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
218 // test Invalid action
219 volumeServiceForAttachAction.validate(mockCommonHeader, Action.DetachVolume, mockAI, mockPayload);
220 status = (Status) Whitebox.getInternalState(volumeServiceForAttachAction, "status");
221 Assert.assertEquals("Should return invalid parameter for action",
222 Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()), status.getCode());
224 // test empty ActionIdentifier
225 volumeServiceForAttachAction.validate(mockCommonHeader, Action.AttachVolume, mockAI, mockPayload);
226 status = (Status) Whitebox.getInternalState(volumeServiceForAttachAction, "status");
227 Assert.assertEquals("should return missing parameter",
228 Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
230 // test empty VSERVER_ID
231 Mockito.doReturn("").when(mockAI).getVserverId();
232 volumeServiceForAttachAction.validate(mockCommonHeader, Action.AttachVolume, mockAI, mockPayload);
233 status = (Status) Whitebox.getInternalState(volumeServiceForAttachAction, "status");
234 Assert.assertEquals("should return invalid parameter",
235 Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()), status.getCode());
237 Mockito.doReturn("vserverId").when(mockAI).getVserverId();
240 volumeServiceForAttachAction.validate(mockCommonHeader, Action.AttachVolume, mockAI, null);
241 Mockito.verify(volumeServiceForAttachAction, times(1)).validateExcludedActIds(any(), any());
242 status = (Status) Whitebox.getInternalState(volumeServiceForAttachAction, "status");
243 Assert.assertEquals("should return missing parameter",
244 Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
246 // test empty payload
247 Mockito.doReturn("").when(mockPayload).getValue();
248 volumeServiceForAttachAction.validate(mockCommonHeader, Action.AttachVolume, mockAI, mockPayload);
249 status = (Status) Whitebox.getInternalState(volumeServiceForAttachAction, "status");
250 Assert.assertEquals("should return invalid parameter",
251 Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()), status.getCode());
253 // test space payload
254 Mockito.doReturn(" ").when(mockPayload).getValue();
255 volumeServiceForAttachAction.validate(mockCommonHeader, Action.AttachVolume, mockAI, mockPayload);
256 status = (Status) Whitebox.getInternalState(volumeServiceForAttachAction, "status");
257 Assert.assertEquals("should return invalid parameter",
258 Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()), status.getCode());
262 public void testValidateForDetachAction() throws Exception {
263 // test commonHeader error
264 volumeServiceForDetachAction.validate(mockCommonHeader, Action.DetachVolume, mockAI, mockPayload);
265 Status status = (Status) Whitebox.getInternalState(volumeServiceForDetachAction, "status");
266 Assert.assertEquals("should return missing parameter",
267 Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
268 Mockito.verify(volumeServiceForDetachAction, times(0)).buildStatusForParamName(any(), any());
269 Mockito.verify(volumeServiceForDetachAction, times(0)).buildStatusForErrorMsg(any(), any());
271 ZULU mockTimeStamp = mock(ZULU.class);
272 Mockito.doReturn(mockTimeStamp).when(mockCommonHeader).getTimestamp();
273 Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
274 Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
275 Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
277 // test Invalid action
278 volumeServiceForDetachAction.validate(mockCommonHeader, Action.AttachVolume, mockAI, mockPayload);
279 status = (Status) Whitebox.getInternalState(volumeServiceForDetachAction, "status");
280 Assert.assertEquals("Should return invalid parameter for action",
281 Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()), status.getCode());
283 // test empty ActionIdentifier
284 volumeServiceForDetachAction.validate(mockCommonHeader, Action.DetachVolume, mockAI, mockPayload);
285 status = (Status) Whitebox.getInternalState(volumeServiceForDetachAction, "status");
286 Assert.assertEquals("should return missing parameter",
287 Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
289 // test empty VSERVER_ID
290 Mockito.doReturn("").when(mockAI).getVserverId();
291 volumeServiceForDetachAction.validate(mockCommonHeader, Action.DetachVolume, mockAI, mockPayload);
292 status = (Status) Whitebox.getInternalState(volumeServiceForDetachAction, "status");
293 Assert.assertEquals("should return invalid parameter",
294 Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()), status.getCode());
296 Mockito.doReturn("vserverId").when(mockAI).getVserverId();
299 volumeServiceForDetachAction.validate(mockCommonHeader, Action.DetachVolume, mockAI, null);
300 Mockito.verify(volumeServiceForDetachAction, times(1)).validateExcludedActIds(any(), any());
301 status = (Status) Whitebox.getInternalState(volumeServiceForDetachAction, "status");
302 Assert.assertEquals("should return missing parameter",
303 Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
305 // test empty payload
306 Mockito.doReturn("").when(mockPayload).getValue();
307 volumeServiceForDetachAction.validate(mockCommonHeader, Action.DetachVolume, mockAI, mockPayload);
308 status = (Status) Whitebox.getInternalState(volumeServiceForDetachAction, "status");
309 Assert.assertEquals("should return invalid parameter",
310 Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()), status.getCode());
312 // test space payload
313 Mockito.doReturn(" ").when(mockPayload).getValue();
314 volumeServiceForDetachAction.validate(mockCommonHeader, Action.DetachVolume, mockAI, mockPayload);
315 status = (Status) Whitebox.getInternalState(volumeServiceForDetachAction, "status");
316 Assert.assertEquals("should return invalid parameter",
317 Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()), status.getCode());