2 * ============LICENSE_START==========================================
4 * ===================================================================
5 * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
6 * ===================================================================
8 * Unless otherwise specified, all software contained herein is licensed
9 * under the Apache License, Version 2.0 (the "License");
10 * you may not use this software 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 * Unless otherwise specified, all documentation contained herein is licensed
22 * under the Creative Commons License, Attribution 4.0 Intl. (the "License");
23 * you may not use this documentation except in compliance with the License.
24 * You may obtain a copy of the License at
26 * https://creativecommons.org/licenses/by/4.0/
28 * Unless required by applicable law or agreed to in writing, documentation
29 * distributed under the License is distributed on an "AS IS" BASIS,
30 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
31 * See the License for the specific language governing permissions and
32 * limitations under the License.
34 * ============LICENSE_END============================================
38 package org.onap.portalapp.portal.controller;
40 import static org.junit.Assert.assertEquals;
42 import java.util.ArrayList;
43 import java.util.List;
45 import javax.servlet.http.HttpServletRequest;
46 import javax.servlet.http.HttpServletResponse;
48 import org.junit.Before;
49 import org.junit.Test;
50 import org.mockito.InjectMocks;
51 import org.mockito.Mock;
52 import org.mockito.Mockito;
53 import org.mockito.MockitoAnnotations;
54 import org.onap.portalapp.portal.controller.BasicAuthAccountController;
55 import org.onap.portalapp.portal.core.MockEPUser;
56 import org.onap.portalapp.portal.domain.BasicAuthCredentials;
57 import org.onap.portalapp.portal.domain.EPEndpoint;
58 import org.onap.portalapp.portal.domain.EPUser;
59 import org.onap.portalapp.portal.ecomp.model.PortalRestResponse;
60 import org.onap.portalapp.portal.ecomp.model.PortalRestStatusEnum;
61 import org.onap.portalapp.portal.framework.MockitoTestSuite;
62 import org.onap.portalapp.portal.service.AdminRolesService;
63 import org.onap.portalapp.portal.service.AdminRolesServiceImpl;
64 import org.onap.portalapp.portal.service.BasicAuthAccountService;
65 import org.onap.portalapp.portal.service.BasicAuthAccountServiceImpl;
66 import org.onap.portalapp.util.EPUserUtils;
68 public class BasicAuthAccountControllerTest extends MockitoTestSuite {
71 BasicAuthAccountService basicAuthAccountService = new BasicAuthAccountServiceImpl();
74 AdminRolesService adminRolesService = new AdminRolesServiceImpl();
77 BasicAuthAccountController basicAuthAccountController = new BasicAuthAccountController();
81 MockitoAnnotations.initMocks(this);
84 MockitoTestSuite mockitoTestSuite = new MockitoTestSuite();
86 HttpServletRequest mockedRequest = mockitoTestSuite.getMockedRequest();
87 HttpServletResponse mockedResponse = mockitoTestSuite.getMockedResponse();
88 NullPointerException nullPointerException = new NullPointerException();
91 EPUserUtils ePUserUtils = new EPUserUtils();
93 MockEPUser mockUser = new MockEPUser();
95 public BasicAuthCredentials basicAuthCredentials() {
96 BasicAuthCredentials basicAuthCredentials = new BasicAuthCredentials();
98 basicAuthCredentials.setId((long) 1);
99 basicAuthCredentials.setApplicationName("test");
100 basicAuthCredentials.setUsername("Test");
101 basicAuthCredentials.setPassword("Password");
102 basicAuthCredentials.setIsActive("YES");
104 List<EPEndpoint> endpoints = new ArrayList<EPEndpoint>();
106 EPEndpoint ePEndpoint = new EPEndpoint();
107 ePEndpoint.setId((long) 1);
108 ePEndpoint.setName("Test");
109 endpoints.add(ePEndpoint);
110 basicAuthCredentials.setEndpoints(endpoints);
112 return basicAuthCredentials;
117 public void createBasicAuthAccountTest() throws Exception {
118 BasicAuthCredentials basicAuthCredentials = basicAuthCredentials();
120 EPUser user = mockUser.mockEPUser();
121 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
122 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
123 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
124 expectedResponse.setMessage("SUCCESS");
125 expectedResponse.setResponse("");
126 PortalRestStatusEnum portalRestStatusEnum = null;
127 expectedResponse.setStatus(portalRestStatusEnum.OK);
130 Mockito.when(basicAuthAccountService.saveBasicAuthAccount(basicAuthCredentials)).thenReturn(accountd);
132 PortalRestResponse<String> actualResponse = basicAuthAccountController.createBasicAuthAccount(mockedRequest,
133 mockedResponse, basicAuthCredentials);
134 assertEquals(actualResponse, expectedResponse);
138 public void createBasicAuthAccountXSSTest() throws Exception {
139 BasicAuthCredentials basicAuthCredentials = basicAuthCredentials();
140 basicAuthCredentials.setPassword("<script>alert(“XSS”);</script>");
142 EPUser user = mockUser.mockEPUser();
143 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
144 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
145 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
146 expectedResponse.setMessage("createBasicAuthAccount() failed, new credential are not safe");
147 expectedResponse.setResponse("");
148 PortalRestStatusEnum portalRestStatusEnum = null;
149 expectedResponse.setStatus(portalRestStatusEnum.ERROR);
152 Mockito.when(basicAuthAccountService.saveBasicAuthAccount(basicAuthCredentials)).thenReturn(accountd);
154 PortalRestResponse<String> actualResponse = basicAuthAccountController.createBasicAuthAccount(mockedRequest,
155 mockedResponse, basicAuthCredentials);
156 assertEquals(actualResponse, expectedResponse);
160 public void createBasicAuthAccountAdminTest() throws Exception {
161 BasicAuthCredentials basicAuthCredentials = basicAuthCredentials();
162 EPUser user = mockUser.mockEPUser();
163 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
164 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
165 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
166 expectedResponse.setMessage("Authorization Required");
167 expectedResponse.setResponse("Admin Only Operation! ");
168 PortalRestStatusEnum portalRestStatusEnum = null;
169 expectedResponse.setStatus(portalRestStatusEnum.ERROR);
171 PortalRestResponse<String> actualResponse = basicAuthAccountController.createBasicAuthAccount(mockedRequest,
172 mockedResponse, basicAuthCredentials);
173 assertEquals(actualResponse, expectedResponse);
177 public void createBasicAuthAccountIfInputNullTest() throws Exception {
178 BasicAuthCredentials basicAuthCredentials = null;
179 EPUser user = mockUser.mockEPUser();
180 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
181 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
182 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
183 expectedResponse.setMessage("FAILURE");
184 expectedResponse.setResponse("newBasicAuthAccount cannot be null or empty");
185 PortalRestStatusEnum portalRestStatusEnum = null;
186 expectedResponse.setStatus(portalRestStatusEnum.ERROR);
187 PortalRestResponse<String> actualResponse = basicAuthAccountController.createBasicAuthAccount(mockedRequest,
188 mockedResponse, basicAuthCredentials);
189 assertEquals(actualResponse, expectedResponse);
193 public void getBasicAuthAccountTest() throws Exception {
194 PortalRestResponse<List<BasicAuthCredentials>> expectedPortalResponse = new PortalRestResponse<List<BasicAuthCredentials>>();
195 List<BasicAuthCredentials> basicAuthCredentialsList = new ArrayList<BasicAuthCredentials>();
196 BasicAuthCredentials basicAuthCredentials = basicAuthCredentials();
197 basicAuthCredentialsList.add(basicAuthCredentials);
199 expectedPortalResponse.setMessage("Success");
200 expectedPortalResponse.setResponse(null);
201 PortalRestStatusEnum portalRestStatusEnum = null;
202 expectedPortalResponse.setStatus(portalRestStatusEnum.OK);
204 EPUser user = mockUser.mockEPUser();
205 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
207 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
208 Mockito.when(basicAuthAccountService.getAccountData()).thenReturn(null);
209 PortalRestResponse<List<BasicAuthCredentials>> actualResponse = basicAuthAccountController
210 .getBasicAuthAccount(mockedRequest, mockedResponse);
211 assertEquals(expectedPortalResponse, actualResponse);
215 public void getBasicAuthAccountIfSuperAdminTest() throws Exception {
216 PortalRestResponse<List<BasicAuthCredentials>> expectedPortalResponse = new PortalRestResponse<List<BasicAuthCredentials>>();
217 List<BasicAuthCredentials> basicAuthCredentialsList = new ArrayList<BasicAuthCredentials>();
218 BasicAuthCredentials basicAuthCredentials = basicAuthCredentials();
219 basicAuthCredentialsList.add(basicAuthCredentials);
221 expectedPortalResponse.setMessage("UnAuthorized! Admin Only Operation");
222 expectedPortalResponse.setResponse(new ArrayList<>());
223 PortalRestStatusEnum portalRestStatusEnum = null;
224 expectedPortalResponse.setStatus(portalRestStatusEnum.ERROR);
226 EPUser user = mockUser.mockEPUser();
227 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
229 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
230 Mockito.when(basicAuthAccountService.getAccountData()).thenReturn(null);
231 PortalRestResponse<List<BasicAuthCredentials>> actualResponse = basicAuthAccountController
232 .getBasicAuthAccount(mockedRequest, mockedResponse);
233 assertEquals(expectedPortalResponse, actualResponse);
237 public void updateAccountTest() throws Exception {
238 BasicAuthCredentials basicAuthCredentials = basicAuthCredentials();
239 EPUser user = mockUser.mockEPUser();
240 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
241 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
242 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
243 expectedResponse.setMessage("SUCCESS");
244 expectedResponse.setResponse("");
245 PortalRestStatusEnum portalRestStatusEnum = null;
246 expectedResponse.setStatus(portalRestStatusEnum.OK);
248 PortalRestResponse<String> actualResponse = basicAuthAccountController.updateAccount(mockedRequest,
249 mockedResponse, accountd, basicAuthCredentials);
250 assertEquals(actualResponse, expectedResponse);
254 public void updateAccountIfSuperAdminTest() throws Exception {
255 BasicAuthCredentials basicAuthCredentials = basicAuthCredentials();
257 EPUser user = mockUser.mockEPUser();
258 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
259 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
260 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
261 expectedResponse.setMessage("Authorization Required");
262 expectedResponse.setResponse("Admin Only Operation! ");
263 PortalRestStatusEnum portalRestStatusEnum = null;
264 expectedResponse.setStatus(portalRestStatusEnum.ERROR);
266 PortalRestResponse<String> actualResponse = basicAuthAccountController.updateAccount(mockedRequest,
267 mockedResponse, accountd, basicAuthCredentials);
268 assertEquals(actualResponse, expectedResponse);
272 public void updateAccountIfInputNullTest() throws Exception {
273 BasicAuthCredentials basicAuthCredentials = null;
275 EPUser user = mockUser.mockEPUser();
276 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
277 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
278 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
279 expectedResponse.setMessage("FAILURE");
280 expectedResponse.setResponse("BasicAuthCredentials cannot be null or empty");
281 PortalRestStatusEnum portalRestStatusEnum = null;
282 expectedResponse.setStatus(portalRestStatusEnum.ERROR);
284 PortalRestResponse<String> actualResponse = basicAuthAccountController.updateAccount(mockedRequest,
285 mockedResponse, accountd, basicAuthCredentials);
286 assertEquals(actualResponse, expectedResponse);
290 public void deleteAccountTest() throws Exception {
291 EPUser user = mockUser.mockEPUser();
292 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
294 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
295 expectedResponse.setMessage("SUCCESS");
296 expectedResponse.setResponse("");
297 PortalRestStatusEnum portalRestStatusEnum = null;
298 expectedResponse.setStatus(portalRestStatusEnum.OK);
300 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
301 PortalRestResponse<String> actualResponse = basicAuthAccountController.deleteAccount(mockedRequest,
302 mockedResponse, accountd);
303 assertEquals(actualResponse, expectedResponse);
307 public void deleteAccountIfNotSuperAdminTest() throws Exception {
308 EPUser user = mockUser.mockEPUser();
309 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
311 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
312 expectedResponse.setMessage("Authorization Required");
313 expectedResponse.setResponse("Admin Only Operation! ");
314 PortalRestStatusEnum portalRestStatusEnum = null;
315 expectedResponse.setStatus(portalRestStatusEnum.ERROR);
317 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
318 PortalRestResponse<String> actualResponse = basicAuthAccountController.deleteAccount(mockedRequest,
319 mockedResponse, accountd);
320 System.out.println(actualResponse);
321 assertEquals(actualResponse, expectedResponse);