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 createBasicAuthAccountAdminTest() throws Exception {
139 BasicAuthCredentials basicAuthCredentials = basicAuthCredentials();
140 EPUser user = mockUser.mockEPUser();
141 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
142 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
143 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
144 expectedResponse.setMessage("Authorization Required");
145 expectedResponse.setResponse("Admin Only Operation! ");
146 PortalRestStatusEnum portalRestStatusEnum = null;
147 expectedResponse.setStatus(portalRestStatusEnum.ERROR);
149 PortalRestResponse<String> actualResponse = basicAuthAccountController.createBasicAuthAccount(mockedRequest,
150 mockedResponse, basicAuthCredentials);
151 assertEquals(actualResponse, expectedResponse);
155 public void createBasicAuthAccountIfInputNullTest() throws Exception {
156 BasicAuthCredentials basicAuthCredentials = null;
157 EPUser user = mockUser.mockEPUser();
158 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
159 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
160 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
161 expectedResponse.setMessage("FAILURE");
162 expectedResponse.setResponse("newBasicAuthAccount cannot be null or empty");
163 PortalRestStatusEnum portalRestStatusEnum = null;
164 expectedResponse.setStatus(portalRestStatusEnum.ERROR);
165 PortalRestResponse<String> actualResponse = basicAuthAccountController.createBasicAuthAccount(mockedRequest,
166 mockedResponse, basicAuthCredentials);
167 assertEquals(actualResponse, expectedResponse);
171 public void getBasicAuthAccountTest() throws Exception {
172 PortalRestResponse<List<BasicAuthCredentials>> expectedPortalResponse = new PortalRestResponse<List<BasicAuthCredentials>>();
173 List<BasicAuthCredentials> basicAuthCredentialsList = new ArrayList<BasicAuthCredentials>();
174 BasicAuthCredentials basicAuthCredentials = basicAuthCredentials();
175 basicAuthCredentialsList.add(basicAuthCredentials);
177 expectedPortalResponse.setMessage("Success");
178 expectedPortalResponse.setResponse(null);
179 PortalRestStatusEnum portalRestStatusEnum = null;
180 expectedPortalResponse.setStatus(portalRestStatusEnum.OK);
182 EPUser user = mockUser.mockEPUser();
183 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
185 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
186 Mockito.when(basicAuthAccountService.getAccountData()).thenReturn(null);
187 PortalRestResponse<List<BasicAuthCredentials>> actualResponse = basicAuthAccountController
188 .getBasicAuthAccount(mockedRequest, mockedResponse);
189 assertEquals(expectedPortalResponse, actualResponse);
193 public void getBasicAuthAccountIfSuperAdminTest() 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("UnAuthorized! Admin Only Operation");
200 expectedPortalResponse.setResponse(new ArrayList<>());
201 PortalRestStatusEnum portalRestStatusEnum = null;
202 expectedPortalResponse.setStatus(portalRestStatusEnum.ERROR);
204 EPUser user = mockUser.mockEPUser();
205 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
207 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
208 Mockito.when(basicAuthAccountService.getAccountData()).thenReturn(null);
209 PortalRestResponse<List<BasicAuthCredentials>> actualResponse = basicAuthAccountController
210 .getBasicAuthAccount(mockedRequest, mockedResponse);
211 assertEquals(expectedPortalResponse, actualResponse);
215 public void updateAccountTest() throws Exception {
216 BasicAuthCredentials basicAuthCredentials = basicAuthCredentials();
217 EPUser user = mockUser.mockEPUser();
218 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
219 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
220 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
221 expectedResponse.setMessage("SUCCESS");
222 expectedResponse.setResponse("");
223 PortalRestStatusEnum portalRestStatusEnum = null;
224 expectedResponse.setStatus(portalRestStatusEnum.OK);
226 PortalRestResponse<String> actualResponse = basicAuthAccountController.updateAccount(mockedRequest,
227 mockedResponse, accountd, basicAuthCredentials);
228 assertEquals(actualResponse, expectedResponse);
232 public void updateAccountIfSuperAdminTest() throws Exception {
233 BasicAuthCredentials basicAuthCredentials = basicAuthCredentials();
235 EPUser user = mockUser.mockEPUser();
236 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
237 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
238 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
239 expectedResponse.setMessage("Authorization Required");
240 expectedResponse.setResponse("Admin Only Operation! ");
241 PortalRestStatusEnum portalRestStatusEnum = null;
242 expectedResponse.setStatus(portalRestStatusEnum.ERROR);
244 PortalRestResponse<String> actualResponse = basicAuthAccountController.updateAccount(mockedRequest,
245 mockedResponse, accountd, basicAuthCredentials);
246 assertEquals(actualResponse, expectedResponse);
250 public void updateAccountIfInputNullTest() throws Exception {
251 BasicAuthCredentials basicAuthCredentials = null;
253 EPUser user = mockUser.mockEPUser();
254 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
255 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
256 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
257 expectedResponse.setMessage("FAILURE");
258 expectedResponse.setResponse("BasicAuthCredentials cannot be null or empty");
259 PortalRestStatusEnum portalRestStatusEnum = null;
260 expectedResponse.setStatus(portalRestStatusEnum.ERROR);
262 PortalRestResponse<String> actualResponse = basicAuthAccountController.updateAccount(mockedRequest,
263 mockedResponse, accountd, basicAuthCredentials);
264 assertEquals(actualResponse, expectedResponse);
268 public void deleteAccountTest() throws Exception {
269 EPUser user = mockUser.mockEPUser();
270 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
272 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
273 expectedResponse.setMessage("SUCCESS");
274 expectedResponse.setResponse("");
275 PortalRestStatusEnum portalRestStatusEnum = null;
276 expectedResponse.setStatus(portalRestStatusEnum.OK);
278 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
279 PortalRestResponse<String> actualResponse = basicAuthAccountController.deleteAccount(mockedRequest,
280 mockedResponse, accountd);
281 assertEquals(actualResponse, expectedResponse);
285 public void deleteAccountIfNotSuperAdminTest() throws Exception {
286 EPUser user = mockUser.mockEPUser();
287 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
289 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
290 expectedResponse.setMessage("Authorization Required");
291 expectedResponse.setResponse("Admin Only Operation! ");
292 PortalRestStatusEnum portalRestStatusEnum = null;
293 expectedResponse.setStatus(portalRestStatusEnum.ERROR);
295 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
296 PortalRestResponse<String> actualResponse = basicAuthAccountController.deleteAccount(mockedRequest,
297 mockedResponse, accountd);
298 System.out.println(actualResponse);
299 assertEquals(actualResponse, expectedResponse);