1 package org.openecomp.portalapp.portal.test.controller;
3 import static org.junit.Assert.assertEquals;
5 import java.util.ArrayList;
8 import javax.servlet.http.HttpServletRequest;
9 import javax.servlet.http.HttpServletResponse;
11 import org.junit.Before;
12 import org.junit.Test;
13 import org.mockito.InjectMocks;
14 import org.mockito.Mock;
15 import org.mockito.Mockito;
16 import org.mockito.MockitoAnnotations;
17 import org.openecomp.portalapp.portal.controller.BasicAuthAccountController;
18 import org.openecomp.portalapp.portal.domain.BasicAuthCredentials;
19 import org.openecomp.portalapp.portal.domain.EPEndpoint;
20 import org.openecomp.portalapp.portal.domain.EPUser;
21 import org.openecomp.portalapp.portal.ecomp.model.PortalRestResponse;
22 import org.openecomp.portalapp.portal.ecomp.model.PortalRestStatusEnum;
23 import org.openecomp.portalapp.portal.service.AdminRolesService;
24 import org.openecomp.portalapp.portal.service.AdminRolesServiceImpl;
25 import org.openecomp.portalapp.portal.service.BasicAuthAccountService;
26 import org.openecomp.portalapp.portal.service.BasicAuthAccountServiceImpl;
27 import org.openecomp.portalapp.portal.test.core.MockEPUser;
28 import org.openecomp.portalapp.test.framework.MockitoTestSuite;
29 import org.openecomp.portalapp.util.EPUserUtils;
31 public class BasicAuthAccountControllerTest extends MockitoTestSuite {
34 BasicAuthAccountService basicAuthAccountService = new BasicAuthAccountServiceImpl();
37 AdminRolesService adminRolesService = new AdminRolesServiceImpl();
40 BasicAuthAccountController basicAuthAccountController = new BasicAuthAccountController();
44 MockitoAnnotations.initMocks(this);
47 MockitoTestSuite mockitoTestSuite = new MockitoTestSuite();
49 HttpServletRequest mockedRequest = mockitoTestSuite.getMockedRequest();
50 HttpServletResponse mockedResponse = mockitoTestSuite.getMockedResponse();
51 NullPointerException nullPointerException = new NullPointerException();
54 EPUserUtils ePUserUtils = new EPUserUtils();
56 MockEPUser mockUser = new MockEPUser();
58 public BasicAuthCredentials basicAuthCredentials() {
59 BasicAuthCredentials basicAuthCredentials = new BasicAuthCredentials();
61 basicAuthCredentials.setId((long) 1);
62 basicAuthCredentials.setApplicationName("test");
63 basicAuthCredentials.setUsername("Test");
64 basicAuthCredentials.setPassword("Password");
65 basicAuthCredentials.setIsActive("YES");
67 List<EPEndpoint> endpoints = new ArrayList<EPEndpoint>();
69 EPEndpoint ePEndpoint = new EPEndpoint();
70 ePEndpoint.setId((long) 1);
71 ePEndpoint.setName("Test");
72 endpoints.add(ePEndpoint);
73 basicAuthCredentials.setEndpoints(endpoints);
75 return basicAuthCredentials;
80 public void createBasicAuthAccountTest() throws Exception {
81 BasicAuthCredentials basicAuthCredentials = basicAuthCredentials();
83 EPUser user = mockUser.mockEPUser();
84 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
85 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
86 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
87 expectedResponse.setMessage("SUCCESS");
88 expectedResponse.setResponse("");
89 expectedResponse.setStatus(PortalRestStatusEnum.OK);
92 Mockito.when(basicAuthAccountService.saveBasicAuthAccount(basicAuthCredentials)).thenReturn(accountd);
94 PortalRestResponse<String> actualResponse = basicAuthAccountController.createBasicAuthAccount(mockedRequest,
95 mockedResponse, basicAuthCredentials);
96 assertEquals(actualResponse, expectedResponse);
100 public void createBasicAuthAccountAdminTest() throws Exception {
101 BasicAuthCredentials basicAuthCredentials = basicAuthCredentials();
102 EPUser user = mockUser.mockEPUser();
103 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
104 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
105 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
106 expectedResponse.setMessage("Authorization Required");
107 expectedResponse.setResponse("Admin Only Operation! ");
108 expectedResponse.setStatus(PortalRestStatusEnum.ERROR);
110 PortalRestResponse<String> actualResponse = basicAuthAccountController.createBasicAuthAccount(mockedRequest,
111 mockedResponse, basicAuthCredentials);
112 assertEquals(actualResponse, expectedResponse);
116 public void createBasicAuthAccountIfInputNullTest() throws Exception {
117 BasicAuthCredentials basicAuthCredentials = null;
118 EPUser user = mockUser.mockEPUser();
119 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
120 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
121 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
122 expectedResponse.setMessage("FAILURE");
123 expectedResponse.setResponse("newBasicAuthAccount cannot be null or empty");
124 expectedResponse.setStatus(PortalRestStatusEnum.ERROR);
125 PortalRestResponse<String> actualResponse = basicAuthAccountController.createBasicAuthAccount(mockedRequest,
126 mockedResponse, basicAuthCredentials);
127 assertEquals(actualResponse, expectedResponse);
131 public void getBasicAuthAccountTest() throws Exception {
132 PortalRestResponse<List<BasicAuthCredentials>> expectedPortalResponse = new PortalRestResponse<List<BasicAuthCredentials>>();
133 List<BasicAuthCredentials> basicAuthCredentialsList = new ArrayList<BasicAuthCredentials>();
134 BasicAuthCredentials basicAuthCredentials = basicAuthCredentials();
135 basicAuthCredentialsList.add(basicAuthCredentials);
137 expectedPortalResponse.setMessage("Success");
138 expectedPortalResponse.setResponse(null);
139 expectedPortalResponse.setStatus(PortalRestStatusEnum.OK);
141 EPUser user = mockUser.mockEPUser();
142 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
144 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
145 Mockito.when(basicAuthAccountService.getAccountData()).thenReturn(null);
146 PortalRestResponse<List<BasicAuthCredentials>> actualResponse = basicAuthAccountController
147 .getBasicAuthAccount(mockedRequest, mockedResponse);
148 assertEquals(expectedPortalResponse, actualResponse);
152 public void getBasicAuthAccountIfSuperAdminTest() throws Exception {
153 PortalRestResponse<List<BasicAuthCredentials>> expectedPortalResponse = new PortalRestResponse<List<BasicAuthCredentials>>();
154 List<BasicAuthCredentials> basicAuthCredentialsList = new ArrayList<BasicAuthCredentials>();
155 BasicAuthCredentials basicAuthCredentials = basicAuthCredentials();
156 basicAuthCredentialsList.add(basicAuthCredentials);
158 expectedPortalResponse.setMessage("UnAuthorized! Admin Only Operation");
159 expectedPortalResponse.setResponse(new ArrayList<>());
160 expectedPortalResponse.setStatus(PortalRestStatusEnum.ERROR);
162 EPUser user = mockUser.mockEPUser();
163 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
165 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
166 Mockito.when(basicAuthAccountService.getAccountData()).thenReturn(null);
167 PortalRestResponse<List<BasicAuthCredentials>> actualResponse = basicAuthAccountController
168 .getBasicAuthAccount(mockedRequest, mockedResponse);
169 assertEquals(expectedPortalResponse, actualResponse);
173 public void updateAccountTest() throws Exception {
174 BasicAuthCredentials basicAuthCredentials = basicAuthCredentials();
175 EPUser user = mockUser.mockEPUser();
176 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
177 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
178 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
179 expectedResponse.setMessage("SUCCESS");
180 expectedResponse.setResponse("");
181 expectedResponse.setStatus(PortalRestStatusEnum.OK);
183 PortalRestResponse<String> actualResponse = basicAuthAccountController.updateAccount(mockedRequest,
184 mockedResponse, accountd, basicAuthCredentials);
185 assertEquals(actualResponse, expectedResponse);
189 public void updateAccountIfSuperAdminTest() throws Exception {
190 BasicAuthCredentials basicAuthCredentials = basicAuthCredentials();
192 EPUser user = mockUser.mockEPUser();
193 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
194 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
195 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
196 expectedResponse.setMessage("Authorization Required");
197 expectedResponse.setResponse("Admin Only Operation! ");
198 expectedResponse.setStatus(PortalRestStatusEnum.ERROR);
200 PortalRestResponse<String> actualResponse = basicAuthAccountController.updateAccount(mockedRequest,
201 mockedResponse, accountd, basicAuthCredentials);
202 assertEquals(actualResponse, expectedResponse);
206 public void updateAccountIfInputNullTest() throws Exception {
207 BasicAuthCredentials basicAuthCredentials = null;
209 EPUser user = mockUser.mockEPUser();
210 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
211 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
212 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
213 expectedResponse.setMessage("FAILURE");
214 expectedResponse.setResponse("BasicAuthCredentials cannot be null or empty");
215 expectedResponse.setStatus(PortalRestStatusEnum.ERROR);
217 PortalRestResponse<String> actualResponse = basicAuthAccountController.updateAccount(mockedRequest,
218 mockedResponse, accountd, basicAuthCredentials);
219 assertEquals(actualResponse, expectedResponse);
223 public void deleteAccountTest() throws Exception {
224 EPUser user = mockUser.mockEPUser();
225 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
227 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
228 expectedResponse.setMessage("SUCCESS");
229 expectedResponse.setResponse("");
230 expectedResponse.setStatus(PortalRestStatusEnum.OK);
232 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
233 PortalRestResponse<String> actualResponse = basicAuthAccountController.deleteAccount(mockedRequest,
234 mockedResponse, accountd);
235 assertEquals(actualResponse, expectedResponse);
239 public void deleteAccountIfNotSuperAdminTest() throws Exception {
240 EPUser user = mockUser.mockEPUser();
241 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
243 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
244 expectedResponse.setMessage("Authorization Required");
245 expectedResponse.setResponse("Admin Only Operation! ");
246 expectedResponse.setStatus(PortalRestStatusEnum.ERROR);
248 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
249 PortalRestResponse<String> actualResponse = basicAuthAccountController.deleteAccount(mockedRequest,
250 mockedResponse, accountd);
251 System.out.println(actualResponse);
252 assertEquals(actualResponse, expectedResponse);