2 * ============LICENSE_START==========================================
4 * ===================================================================
5 * Copyright (C) 2017-2018 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;
41 import static org.junit.Assert.assertNull;
43 import java.io.PrintWriter;
44 import java.io.StringWriter;
45 import java.util.ArrayList;
46 import java.util.HashMap;
47 import java.util.List;
50 import javax.servlet.http.HttpServletRequest;
51 import javax.servlet.http.HttpServletResponse;
53 import org.json.JSONObject;
54 import org.junit.Before;
55 import org.junit.Test;
56 import org.junit.runner.RunWith;
57 import org.mockito.InjectMocks;
58 import org.mockito.Matchers;
59 import org.mockito.Mock;
60 import org.mockito.Mockito;
61 import org.mockito.MockitoAnnotations;
62 import org.onap.portalapp.portal.core.MockEPUser;
63 import org.onap.portalapp.portal.domain.CentralV2RoleFunction;
64 import org.onap.portalapp.portal.domain.EPApp;
65 import org.onap.portalapp.portal.domain.EPUser;
66 import org.onap.portalapp.portal.ecomp.model.PortalRestResponse;
67 import org.onap.portalapp.portal.ecomp.model.PortalRestStatusEnum;
68 import org.onap.portalapp.portal.framework.MockitoTestSuite;
69 import org.onap.portalapp.portal.service.ExternalAccessRolesService;
70 import org.onap.portalapp.portal.service.ExternalAccessRolesServiceImpl;
71 import org.onap.portalapp.portal.transport.CentralRole;
72 import org.onap.portalapp.portal.transport.CentralRoleFunction;
73 import org.onap.portalapp.portal.transport.CentralUser;
74 import org.onap.portalapp.portal.transport.CentralV2Role;
75 import org.onap.portalapp.portal.transport.ExternalRequestFieldsValidator;
76 import org.onap.portalapp.portal.utils.EPCommonSystemProperties;
77 import org.onap.portalapp.portal.utils.EcompPortalUtils;
78 import org.onap.portalapp.portal.utils.PortalConstants;
79 import org.onap.portalsdk.core.domain.AuditLog;
80 import org.onap.portalsdk.core.domain.Role;
81 import org.onap.portalsdk.core.domain.User;
82 import org.onap.portalsdk.core.restful.domain.EcompRole;
83 import org.onap.portalsdk.core.restful.domain.EcompUser;
84 import org.onap.portalsdk.core.service.AuditService;
85 import org.onap.portalsdk.core.service.UserService;
86 import org.onap.portalsdk.core.service.UserServiceCentalizedImpl;
87 import org.onap.portalsdk.core.util.SystemProperties;
88 import org.powermock.api.mockito.PowerMockito;
89 import org.powermock.core.classloader.annotations.PrepareForTest;
90 import org.powermock.modules.junit4.PowerMockRunner;
91 import org.springframework.http.HttpStatus;
92 import org.springframework.http.ResponseEntity;
93 import org.springframework.web.client.HttpClientErrorException;
95 import com.fasterxml.jackson.core.JsonProcessingException;
96 import com.fasterxml.jackson.databind.DeserializationFeature;
97 import com.fasterxml.jackson.databind.ObjectMapper;
99 @RunWith(PowerMockRunner.class)
100 @PrepareForTest({ EcompPortalUtils.class, PortalConstants.class, SystemProperties.class,
101 EPCommonSystemProperties.class })
102 public class ExternalAccessRolesControllerTest {
104 ExternalAccessRolesService externalAccessRolesService = new ExternalAccessRolesServiceImpl();
106 ExternalAccessRolesController externalAccessRolesController;
108 UserService userservice = new UserServiceCentalizedImpl();
110 AuditService auditService;
113 public void setup() {
114 MockitoAnnotations.initMocks(this);
118 AuditLog auditLog = new AuditLog();
119 MockitoTestSuite mockitoTestSuite = new MockitoTestSuite();
120 HttpServletRequest mockedRequest = mockitoTestSuite.getMockedRequest();
121 HttpServletResponse mockedResponse = mockitoTestSuite.getMockedResponse();
122 NullPointerException nullPointerException = new NullPointerException();
123 HttpClientErrorException httpClientErrorException = new HttpClientErrorException(HttpStatus.BAD_REQUEST, "Failed");
124 MockEPUser mockUser = new MockEPUser();
125 String loginId = "guestT";
126 String uebKey = "testUebKey";
128 public EPApp mockApp() {
129 EPApp app = new EPApp();
131 app.setImageUrl("test");
132 app.setDescription("test");
133 app.setNotes("test");
136 app.setAppRestEndpoint("test");
137 app.setAlternateUrl("test");
139 app.setMlAppName("test");
140 app.setMlAppAdminId("test");
141 app.setUsername("test");
142 app.setAppPassword("test");
144 app.setEnabled(false);
145 app.setUebKey("test");
146 app.setUebSecret("test");
147 app.setUebTopicName("test");
153 public void getUserTest() throws Exception {
154 CentralUser expectedCentralUser = new CentralUser(null, null, null, null, null, null, null, null, loginId,
155 loginId, loginId, loginId, loginId, loginId, loginId, null, loginId, loginId, loginId, loginId, loginId,
156 loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId,
157 loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId,
158 loginId, null, false, false, null, null, false, loginId, null);
159 String loginId = "test";
160 StringWriter sw = new StringWriter();
161 PrintWriter writer = new PrintWriter(sw);
162 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
163 EPApp app = mockApp();
164 app.setCentralAuth(true);
165 List<EPApp> appList = new ArrayList<>();
167 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
168 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
169 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
170 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
171 Mockito.when(externalAccessRolesService.getUserRoles(loginId, mockedRequest.getHeader("uebkey")))
172 .thenReturn(expectedCentralUser);
173 CentralUser actualCentralUser = externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId);
174 assertEquals(actualCentralUser.isActive(), expectedCentralUser.isActive());
178 public void getUserExceptionTest() throws Exception {
179 String reason = getInvalidKeyJson();
180 StringWriter sw = new StringWriter();
181 PrintWriter writer = new PrintWriter(sw);
182 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
183 externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId);
184 String result = sw.getBuffer().toString().trim();
185 assertEquals(reason, result);
189 public void getUserXSSTest() throws Exception {
190 String loginId = "<script ~~~>alert(0%0)</script ~~~>";
191 String expected = getXSSKeyJson();
192 StringWriter sw = new StringWriter();
193 PrintWriter writer = new PrintWriter(sw);
194 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
195 externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId);
196 String actual = sw.getBuffer().toString().trim();
197 assertEquals(expected, actual);
201 public void getV2UserListTest() throws Exception {
202 String expectedCentralUser = "test";
203 String loginId = "test";
204 EPApp app = mockApp();
205 app.setCentralAuth(true);
206 List<EPApp> appList = new ArrayList<>();
208 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
209 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
210 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
211 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
212 Mockito.when(externalAccessRolesService.getV2UserWithRoles(loginId, mockedRequest.getHeader("uebkey")))
213 .thenReturn(expectedCentralUser);
214 String actualString = externalAccessRolesController.getV2UserList(mockedRequest, mockedResponse, loginId);
215 assertEquals(actualString, expectedCentralUser);
218 @Test(expected = NullPointerException.class)
219 public void getV2UserListExceptionTest() throws Exception {
220 String expectedCentralUser = null;
221 String loginId = "test";
222 EPApp app = mockApp();
223 app.setCentralAuth(true);
224 List<EPApp> appList = new ArrayList<>();
226 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
227 ResponseEntity<String> response = null;
228 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
229 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
230 Mockito.when(externalAccessRolesService.getV2UserWithRoles(loginId, mockedRequest.getHeader("uebkey")))
231 .thenReturn(expectedCentralUser);
232 String actualString = externalAccessRolesController.getV2UserList(mockedRequest, mockedResponse, loginId);
233 assertEquals(actualString, expectedCentralUser);
237 public void getRolesForAppCentralRoleTest() throws Exception {
238 List<CentralRole> expectedCentralRoleList = new ArrayList<>();
239 List<EPApp> applicationList = new ArrayList<>();
240 List<CentralV2Role> centralV2RoleList = new ArrayList<>();
241 List<CentralRole> centralRoleList = new ArrayList<>();
242 EPApp app = mockApp();
243 app.setCentralAuth(true);
244 applicationList.add(app);
245 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
246 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
247 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
248 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
249 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
250 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey)))
251 .thenReturn(centralV2RoleList);
252 Mockito.when(externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(centralV2RoleList))
253 .thenReturn(centralRoleList);
254 List<CentralRole> actualCentralRoleList = externalAccessRolesController.getRolesForApp(mockedRequest,
256 assertEquals(actualCentralRoleList.size(), expectedCentralRoleList.size());
259 @Test(expected = NullPointerException.class)
260 public void getRolesForAppCentralRoleExceptionTest() throws Exception {
261 List<EPApp> applicationList = new ArrayList<>();
262 List<CentralV2Role> centralV2RoleList = new ArrayList<>();
263 List<CentralRole> centralRoleList = new ArrayList<>();
264 EPApp app = mockApp();
265 app.setCentralAuth(true);
266 applicationList.add(app);
267 ResponseEntity<String> response = null;
268 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
269 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
270 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
271 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
272 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey)))
273 .thenReturn(centralV2RoleList);
274 Mockito.when(externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(centralV2RoleList))
275 .thenReturn(centralRoleList);
276 List<CentralRole> actualCentralRoleList = externalAccessRolesController.getRolesForApp(mockedRequest,
278 assertEquals(null, actualCentralRoleList);
282 public void getV2RolesForAppTest() throws Exception {
283 List<CentralRole> expectedCentralRoleList = new ArrayList<>();
284 List<EPApp> applicationList = new ArrayList<>();
285 List<CentralV2Role> centralV2Role = new ArrayList<>();
286 EPApp app = mockApp();
287 app.setCentralAuth(true);
288 applicationList.add(app);
289 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
290 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
291 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
292 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
293 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
294 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey)))
295 .thenReturn(centralV2Role);
296 List<CentralV2Role> actualCentralV2Role = externalAccessRolesController.getV2RolesForApp(mockedRequest,
298 assertEquals(actualCentralV2Role.size(), expectedCentralRoleList.size());
301 @Test(expected = NullPointerException.class)
302 public void getV2RolesForAppExceptionTest() throws Exception {
303 List<CentralRole> expectedCentralRoleList = new ArrayList<>();
304 List<EPApp> applicationList = new ArrayList<>();
305 List<CentralV2Role> centralV2Role = new ArrayList<>();
306 EPApp app = mockApp();
307 app.setCentralAuth(true);
308 applicationList.add(app);
309 ResponseEntity<String> response = null;
310 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
311 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
312 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
313 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
314 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey)))
315 .thenReturn(centralV2Role);
316 List<CentralV2Role> actualCentralV2Role = externalAccessRolesController.getV2RolesForApp(mockedRequest,
318 assertEquals(actualCentralV2Role.size(), expectedCentralRoleList.size());
321 @Test(expected = NullPointerException.class)
322 public void getRolesForAppTest() throws Exception {
323 List<EPApp> applicationList = new ArrayList<>();
324 List<CentralV2Role> answer = new ArrayList<>();
325 EPApp app = mockApp();
326 applicationList.add(app);
327 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
328 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
329 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey))).thenReturn(answer);
330 assertEquals(externalAccessRolesController.getRolesForApp(mockedRequest, mockedResponse), null);
333 @Test(expected = NullPointerException.class)
334 public void getRolesForAppExceptionTest() throws Exception {
335 List<EPApp> applicationList = new ArrayList<>();
336 EPApp app = mockApp();
337 applicationList.add(app);
338 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
339 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
340 externalAccessRolesController.getRolesForApp(mockedRequest, mockedResponse);
341 List<CentralV2Role> role = externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey));
342 assertEquals(null, role);
346 public void getRoleFunctionsListTest() throws Exception {
347 List<CentralRole> expectedCentralRoleList = new ArrayList<>();
348 List<CentralRoleFunction> roleFuncList = new ArrayList<>();
349 List<EPApp> applicationList = new ArrayList<>();
350 List<CentralV2RoleFunction> centralV2RoleFunction = new ArrayList<>();
351 EPApp app = mockApp();
352 app.setCentralAuth(true);
353 applicationList.add(app);
354 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
355 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
356 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
357 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
358 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
359 Mockito.when(externalAccessRolesService.getRoleFuncList(mockedRequest.getHeader("uebkey")))
360 .thenReturn(centralV2RoleFunction);
361 Mockito.when(externalAccessRolesService.convertCentralRoleFunctionToRoleFunctionObject(centralV2RoleFunction))
362 .thenReturn(roleFuncList);
363 List<CentralRoleFunction> actualCentralRoleFunction = externalAccessRolesController
364 .getRoleFunctionsList(mockedRequest, mockedResponse);
365 assertEquals(actualCentralRoleFunction.size(), expectedCentralRoleList.size());
369 public void getRoleFunctionsListExceptionTest() throws Exception {
370 String reason = getInvalidKeyJson();
371 StringWriter sw = new StringWriter();
372 PrintWriter writer = new PrintWriter(sw);
373 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
374 externalAccessRolesController.getRoleFunctionsList(mockedRequest, mockedResponse);
375 String result = sw.getBuffer().toString().trim();
376 assertEquals(reason, result);
380 public void getV2RoleFunctionsListTest() throws Exception {
381 List<CentralV2RoleFunction> expectedCentralV2RoleFunctionList = new ArrayList<>();
382 List<EPApp> applicationList = new ArrayList<>();
383 List<CentralV2RoleFunction> centralV2RoleFunction = new ArrayList<>();
384 EPApp app = mockApp();
385 app.setCentralAuth(true);
386 applicationList.add(app);
387 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
388 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
389 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
390 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
391 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
392 Mockito.when(externalAccessRolesService.getRoleFuncList(mockedRequest.getHeader("uebkey")))
393 .thenReturn(centralV2RoleFunction);
394 List<CentralV2RoleFunction> actualCentralV2RoleFunctionList = externalAccessRolesController
395 .getV2RoleFunctionsList(mockedRequest, mockedResponse);
396 assertEquals(actualCentralV2RoleFunctionList.size(), expectedCentralV2RoleFunctionList.size());
400 public void getV2RoleFunctionsListExceptionTest() throws Exception {
401 String reason = getInvalidKeyJson();
402 StringWriter sw = new StringWriter();
403 PrintWriter writer = new PrintWriter(sw);
404 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
405 externalAccessRolesController.getV2RoleFunctionsList(mockedRequest, mockedResponse);
406 String result = sw.getBuffer().toString().trim();
407 assertEquals(reason, result);
411 public void getRoleInfoValidationTest() throws Exception {
412 CentralRole expectedCentralRole = null;
413 List<EPApp> applicationList = new ArrayList<>();
415 CentralV2Role centralV2Role = new CentralV2Role();
416 EPApp app = mockApp();
417 app.setCentralAuth(true);
418 applicationList.add(app);
419 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
420 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
421 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
422 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
423 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader("uebkey")))
424 .thenReturn(centralV2Role);
425 CentralRole actualCentralRole = externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse,
427 assertEquals(actualCentralRole, expectedCentralRole);
431 public void getRoleInfoTest() throws Exception {
432 String reason = getInvalidKeyJson();
433 StringWriter sw = new StringWriter();
434 PrintWriter writer = new PrintWriter(sw);
435 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
436 CentralV2Role answer = new CentralV2Role();
438 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader(uebKey)))
440 externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse, roleId);
441 String result = sw.getBuffer().toString().trim();
442 assertEquals(reason, result);
446 public void getRoleInfoExceptionTest() throws Exception {
447 String reason = getInvalidKeyJson();
448 StringWriter sw = new StringWriter();
449 PrintWriter writer = new PrintWriter(sw);
450 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
452 assertNull(externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse, roleId));
453 String result = sw.getBuffer().toString().trim();
454 assertEquals(reason, result);
458 public void getV2RoleInfoValidationTest() throws Exception {
459 CentralV2Role expectedCentralRole = new CentralV2Role();
460 expectedCentralRole.setActive(false);
461 List<EPApp> applicationList = new ArrayList<>();
463 CentralV2Role centralV2Role = new CentralV2Role();
464 EPApp app = mockApp();
465 app.setCentralAuth(true);
466 applicationList.add(app);
467 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
468 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
469 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
470 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
471 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader("uebkey")))
472 .thenReturn(centralV2Role);
473 CentralV2Role actualCentralRole = externalAccessRolesController.getV2RoleInfo(mockedRequest, mockedResponse,
475 assertEquals(actualCentralRole.getActive(), expectedCentralRole.getActive());
479 public void getV2RoleInfoTest() throws Exception {
480 String reason = getInvalidKeyJson();
481 StringWriter sw = new StringWriter();
482 PrintWriter writer = new PrintWriter(sw);
483 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
484 CentralV2Role answer = new CentralV2Role();
486 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader(uebKey)))
488 externalAccessRolesController.getV2RoleInfo(mockedRequest, mockedResponse, roleId);
489 String result = sw.getBuffer().toString().trim();
490 assertEquals(reason, result);
494 public void getV2RoleInfoExceptionTest() throws Exception {
495 String reason = getInvalidKeyJson();
496 StringWriter sw = new StringWriter();
497 PrintWriter writer = new PrintWriter(sw);
498 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
500 assertNull(externalAccessRolesController.getV2RoleInfo(mockedRequest, mockedResponse, roleId));
501 String result = sw.getBuffer().toString().trim();
502 assertEquals(reason, result);
506 public void getV2RoleFunctionTest() throws Exception {
507 CentralV2RoleFunction expectedCentralV2RoleFunction = new CentralV2RoleFunction();
508 expectedCentralV2RoleFunction.setCode("test");
509 List<EPApp> applicationList = new ArrayList<>();
510 String code = "test";
511 CentralV2RoleFunction centralV2RoleFunction = new CentralV2RoleFunction();
512 centralV2RoleFunction.setCode("test");
513 EPApp app = mockApp();
514 app.setCentralAuth(true);
515 applicationList.add(app);
516 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
517 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
518 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
519 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
520 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader("uebkey")))
521 .thenReturn(centralV2RoleFunction);
522 CentralV2RoleFunction actualCentralV2RoleFunction = externalAccessRolesController
523 .getV2RoleFunction(mockedRequest, mockedResponse, code);
524 assertEquals(actualCentralV2RoleFunction.getCode(), expectedCentralV2RoleFunction.getCode());
529 public void getV2RoleFunctionNullCheckTest() throws Exception {
530 CentralV2RoleFunction expectedCentralV2RoleFunction = new CentralV2RoleFunction();
531 List<EPApp> applicationList = new ArrayList<>();
532 String code = "test";
533 CentralV2RoleFunction centralV2RoleFunction = null;
534 EPApp app = mockApp();
535 app.setCentralAuth(true);
536 applicationList.add(app);
537 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
538 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
539 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
540 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
541 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader("uebkey")))
542 .thenReturn(centralV2RoleFunction);
543 CentralV2RoleFunction actualCentralV2RoleFunction = externalAccessRolesController
544 .getV2RoleFunction(mockedRequest, mockedResponse, code);
545 assertEquals(actualCentralV2RoleFunction.getAction(), expectedCentralV2RoleFunction.getAction());
549 public void getV2RoleFunctionExceptionTest() throws Exception {
550 String reason = getInvalidKeyJson();
551 StringWriter sw = new StringWriter();
552 PrintWriter writer = new PrintWriter(sw);
553 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
554 String code = "test";
555 assertNull(externalAccessRolesController.getV2RoleFunction(mockedRequest, mockedResponse, code));
556 String result = sw.getBuffer().toString().trim();
557 assertEquals(reason, result);
561 public void getRoleFunctionTest() throws Exception {
562 EPApp mockApp = mockApp();
563 mockApp.setCentralAuth(true);
564 List<EPApp> mockAppList = new ArrayList<>();
565 mockAppList.add(mockApp);
566 StringWriter sw = new StringWriter();
567 PrintWriter writer = new PrintWriter(sw);
568 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
569 CentralV2RoleFunction roleFunction1 = new CentralV2RoleFunction();
570 CentralRoleFunction roleFunction2 = new CentralRoleFunction();
571 roleFunction1.setCode("test2");
572 String code = "test_menu";
573 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
574 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(mockAppList);
575 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
576 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(mockAppList.get(0))).thenReturn(response);
577 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader("uebkey")))
578 .thenReturn(roleFunction1);
579 CentralRoleFunction returnedValue = externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse,
581 assertEquals(returnedValue, roleFunction2);
582 String result = sw.getBuffer().toString().trim();
583 assertEquals("", result);
587 public void getRoleFunctionExceptionTest() throws Exception {
588 String reason = getInvalidKeyJson();
589 StringWriter sw = new StringWriter();
590 PrintWriter writer = new PrintWriter(sw);
591 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
592 String code = "test_menu";
593 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader(uebKey)))
594 .thenThrow(httpClientErrorException);
595 assertEquals(new CentralRoleFunction(),
596 externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse, code));
597 String result = sw.getBuffer().toString().trim();
598 assertEquals(reason, result);
602 public void getRoleFunctionXSSTest() throws Exception {
603 String expected = getXSSKeyJson();
604 EPApp mockApp = mockApp();
605 mockApp.setCentralAuth(true);
606 List<EPApp> mockAppList = new ArrayList<>();
607 mockAppList.add(mockApp);
608 StringWriter sw = new StringWriter();
609 PrintWriter writer = new PrintWriter(sw);
610 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
611 CentralV2RoleFunction roleFunction1 = new CentralV2RoleFunction();
612 CentralRoleFunction roleFunction2 = new CentralRoleFunction();
613 roleFunction1.setCode("test2");
614 String code = "<script>alert(‘XSS’)</script>";
615 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
616 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(mockAppList);
617 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
618 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(mockAppList.get(0))).thenReturn(response);
619 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader("uebkey")))
620 .thenReturn(roleFunction1);
621 CentralRoleFunction returnedValue = externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse,
623 assertEquals(returnedValue, roleFunction2);
624 String result = sw.getBuffer().toString().trim();
625 assertEquals(expected, result);
629 public void saveRoleFunctionIfIsNotDeletedTest() throws Exception {
630 List<EPApp> applicationList = new ArrayList<>();
631 EPApp app = mockApp();
632 applicationList.add(app);
633 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
634 PortalRestResponse<String> portalRestResponse = null;
635 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
636 expectedportalRestResponse.setMessage(null);
637 expectedportalRestResponse.setResponse("Failed");
638 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
640 CentralV2RoleFunction centralV2RoleFunction = new CentralV2RoleFunction();
641 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
642 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
643 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
644 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
645 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(centralV2RoleFunction, app)).thenReturn(false);
646 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, data);
647 assertEquals(portalRestResponse, expectedportalRestResponse);
651 public void saveRoleFunctionExceptionTest() throws Exception {
652 List<EPApp> applicationList = new ArrayList<>();
653 EPApp app = mockApp();
654 app.setCentralAuth(true);
655 applicationList.add(app);
656 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
657 PortalRestResponse<String> portalRestResponse = null;
658 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
659 expectedportalRestResponse.setMessage(null);
660 expectedportalRestResponse.setResponse("Failed");
661 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
662 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
663 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
664 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
665 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
666 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, null);
667 assertEquals(portalRestResponse, expectedportalRestResponse);
671 public void saveRoleFunctionTest() throws Exception {
672 List<EPApp> applicationList = new ArrayList<>();
673 EPUser user = mockUser.mockEPUser();
674 List<EPUser> userList = new ArrayList<>();
676 EPApp app = mockApp();
677 app.setCentralAuth(true);
678 applicationList.add(app);
679 JSONObject roleFunc = new JSONObject();
680 roleFunc.put("type", "test_type");
681 roleFunc.put("code", "test_instance");
682 roleFunc.put("action", "test_action");
683 roleFunc.put("name", "test_name");
684 ObjectMapper mapper = new ObjectMapper();
685 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
686 CentralV2RoleFunction saveRoleFunc = mapper.readValue(roleFunc.toString(), CentralV2RoleFunction.class);
687 saveRoleFunc.setAppId(app.getId());
688 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
689 PortalRestResponse<String> portalRestResponse = null;
690 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
691 expectedportalRestResponse.setMessage("Successfully saved!");
692 expectedportalRestResponse.setResponse("Success");
693 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
694 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
695 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
696 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
697 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
698 Mockito.when(externalAccessRolesService.getRoleFunction("test_type|test_instance|test_action", app.getUebKey()))
700 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(Matchers.any(CentralV2RoleFunction.class),
701 Matchers.any(EPApp.class))).thenReturn(true);
702 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader(Matchers.anyString())))
703 .thenReturn(userList);
704 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(Matchers.anyString())))
705 .thenReturn(applicationList);
706 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse,
707 roleFunc.toString());
708 assertEquals(portalRestResponse, expectedportalRestResponse);
712 public void saveRoleFunctionXSSTest() throws Exception {
713 List<EPApp> applicationList = new ArrayList<>();
714 EPUser user = mockUser.mockEPUser();
715 List<EPUser> userList = new ArrayList<>();
717 EPApp app = mockApp();
718 app.setCentralAuth(true);
719 applicationList.add(app);
720 JSONObject roleFunc = new JSONObject();
721 roleFunc.put("type", "<script>alert(“XSS”)</script> ");
722 roleFunc.put("code", "test_instance");
723 roleFunc.put("action", "test_action");
724 roleFunc.put("name", "test_name");
725 ObjectMapper mapper = new ObjectMapper();
726 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
727 CentralV2RoleFunction saveRoleFunc = mapper.readValue(roleFunc.toString(), CentralV2RoleFunction.class);
728 saveRoleFunc.setAppId(app.getId());
729 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
730 PortalRestResponse<String> portalRestResponse = null;
731 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
732 expectedportalRestResponse.setMessage("Failed to roleFunc, not valid data.");
733 expectedportalRestResponse.setResponse("Failed");
734 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
735 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
736 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
737 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
738 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
739 Mockito.when(externalAccessRolesService.getRoleFunction("test_type|test_instance|test_action", app.getUebKey()))
741 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(Matchers.any(CentralV2RoleFunction.class),
742 Matchers.any(EPApp.class))).thenReturn(true);
743 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader(Matchers.anyString())))
744 .thenReturn(userList);
745 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(Matchers.anyString())))
746 .thenReturn(applicationList);
747 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse,
748 roleFunc.toString());
749 assertEquals(expectedportalRestResponse, portalRestResponse);
753 public void deleteRoleFunctionTest() throws Exception {
754 PowerMockito.mockStatic(EcompPortalUtils.class);
755 PowerMockito.mockStatic(SystemProperties.class);
756 PowerMockito.mockStatic(EPCommonSystemProperties.class);
757 PowerMockito.mockStatic(PortalConstants.class);
758 PortalRestResponse<String> portalRestResponse = null;
759 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
760 expectedportalRestResponse.setMessage("Successfully Deleted");
761 expectedportalRestResponse.setResponse("Success");
762 EPUser user = mockUser.mockEPUser();
763 List<EPUser> userList = new ArrayList<>();
765 EPApp app = mockApp();
766 app.setCentralAuth(true);
767 List<EPApp> appList = new ArrayList<>();
769 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
770 String code = "testNew";
771 Mockito.when(mockedRequest.getHeader("LoginId")).thenReturn("guestT");
772 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
773 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
774 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
775 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
776 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
777 Mockito.when(externalAccessRolesService.deleteCentralRoleFunction(code, app)).thenReturn(true);
778 portalRestResponse = externalAccessRolesController.deleteRoleFunction(mockedRequest, mockedResponse, code);
779 assertEquals(portalRestResponse, expectedportalRestResponse);
783 public void deleteRoleFunctionXSSTest() throws Exception {
784 PowerMockito.mockStatic(EcompPortalUtils.class);
785 PowerMockito.mockStatic(SystemProperties.class);
786 PowerMockito.mockStatic(EPCommonSystemProperties.class);
787 PowerMockito.mockStatic(PortalConstants.class);
788 PortalRestResponse<String> portalRestResponse = null;
789 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
790 expectedportalRestResponse.setMessage("Failed to deleteRoleFunction, not valid data.");
791 expectedportalRestResponse.setResponse("Failed");
792 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
793 EPUser user = mockUser.mockEPUser();
794 List<EPUser> userList = new ArrayList<>();
796 EPApp app = mockApp();
797 app.setCentralAuth(true);
798 List<EPApp> appList = new ArrayList<>();
800 String code = "<script>alert(‘XSS’)</script>";
801 Mockito.when(mockedRequest.getHeader("LoginId")).thenReturn("guestT");
802 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
803 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
804 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
805 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
806 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
807 Mockito.when(externalAccessRolesService.deleteCentralRoleFunction(code, app)).thenReturn(true);
808 portalRestResponse = externalAccessRolesController.deleteRoleFunction(mockedRequest, mockedResponse, code);
809 assertEquals(portalRestResponse, expectedportalRestResponse);
813 public void getActiveRolesTest() throws Exception {
814 String reason = getInvalidKeyJson();
815 StringWriter sw = new StringWriter();
816 PrintWriter writer = new PrintWriter(sw);
817 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
818 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey))).thenReturn(null);
819 List<CentralRole> expectedCenRole = externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
820 assertNull(expectedCenRole);
821 String result = sw.getBuffer().toString().trim();
822 assertEquals(reason, result);
826 public void getActiveRolesValidationTest() throws Exception {
827 List<CentralRole> expectedRolesList = null;
828 EPApp app = mockApp();
829 app.setCentralAuth(true);
830 List<EPApp> appList = new ArrayList<>();
832 List<CentralV2Role> cenRoles = new ArrayList<>();
833 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
834 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
835 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
836 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
837 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader("uebkey"))).thenReturn(cenRoles);
838 Mockito.when(externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(cenRoles))
839 .thenReturn(expectedRolesList);
840 List<CentralRole> actualRolesList = externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
841 assertEquals(actualRolesList, expectedRolesList);
845 public void getActiveRolesExceptionTest() throws Exception {
846 String reason = getInvalidKeyJson();
847 StringWriter sw = new StringWriter();
848 PrintWriter writer = new PrintWriter(sw);
849 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
850 externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
851 String result = sw.getBuffer().toString().trim();
852 assertEquals(reason, result);
856 * It return JSON string which has error information
858 * @return JSON String
859 * @throws JsonProcessingException
861 private String getInvalidKeyJson() throws JsonProcessingException {
862 final Map<String, String> uebkeyResponse = new HashMap<>();
864 ObjectMapper mapper = new ObjectMapper();
865 uebkeyResponse.put("error", "Invalid credentials!");
866 reason = mapper.writeValueAsString(uebkeyResponse);
870 private String getXSSKeyJson() throws JsonProcessingException {
871 final Map<String, String> uebkeyResponse = new HashMap<>();
873 ObjectMapper mapper = new ObjectMapper();
874 uebkeyResponse.put("error", "Data is not valid");
875 reason = mapper.writeValueAsString(uebkeyResponse);
880 public void deleteDependcyRoleRecordExceptionTest() {
881 PortalRestResponse<String> portalRestResponse = null;
882 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
883 expectedportalRestResponse.setMessage("Invalid credentials!");
884 expectedportalRestResponse.setResponse("Failed");
885 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
887 portalRestResponse = externalAccessRolesController.deleteDependencyRoleRecord(mockedRequest, mockedResponse,
889 assertEquals(expectedportalRestResponse, portalRestResponse);
893 public void bulkUploadFunctionsTest() throws Exception {
895 Mockito.when(externalAccessRolesService.bulkUploadFunctions(mockedRequest.getHeader(uebKey)))
897 PortalRestResponse<String> portalRestResponse = null;
898 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
899 expectedportalRestResponse.setMessage("Successfully added: 0");
900 expectedportalRestResponse.setResponse("Success");
901 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
902 portalRestResponse = externalAccessRolesController.bulkUploadFunctions(mockedRequest, mockedResponse);
903 assertEquals(portalRestResponse, expectedportalRestResponse);
907 public void bulkUploadFunctionsExceptionTest() throws Exception {
908 Mockito.when(externalAccessRolesService.bulkUploadFunctions(mockedRequest.getHeader(uebKey)))
909 .thenThrow(httpClientErrorException);
910 PortalRestResponse<String> portalRestResponse = null;
911 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
912 expectedportalRestResponse.setMessage("Failed to bulkUploadFunctions");
913 expectedportalRestResponse.setResponse("Failed");
914 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
915 portalRestResponse = externalAccessRolesController.bulkUploadFunctions(mockedRequest, mockedResponse);
916 assertEquals(portalRestResponse, expectedportalRestResponse);
920 public void bulkUploadRolesTest() throws Exception {
922 PortalRestResponse<String> portalRestResponse = null;
923 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
924 expectedportalRestResponse.setMessage("Successfully added: 0");
925 expectedportalRestResponse.setResponse("Success");
926 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
927 Mockito.when(externalAccessRolesService.bulkUploadRoles(mockedRequest.getHeader(uebKey))).thenReturn(result);
928 portalRestResponse = externalAccessRolesController.bulkUploadRoles(mockedRequest, mockedResponse);
929 assertEquals(portalRestResponse, expectedportalRestResponse);
933 public void bulkUploadRolesTestException() throws Exception {
934 Mockito.when(externalAccessRolesService.bulkUploadRoles(mockedRequest.getHeader(uebKey)))
935 .thenThrow(httpClientErrorException);
936 PortalRestResponse<String> portalRestResponse = null;
937 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
938 expectedportalRestResponse.setMessage("Failed to bulkUploadRoles");
939 expectedportalRestResponse.setResponse("Failed");
940 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
941 portalRestResponse = externalAccessRolesController.bulkUploadRoles(mockedRequest, mockedResponse);
942 assertEquals(portalRestResponse, expectedportalRestResponse);
946 public void bulkUploadRoleFunctionsTest() throws Exception {
948 PortalRestResponse<String> portalRestResponse = null;
949 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
950 expectedportalRestResponse.setMessage("Successfully added: 0");
951 expectedportalRestResponse.setResponse("Success");
952 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
953 Mockito.when(externalAccessRolesService.bulkUploadRolesFunctions(mockedRequest.getHeader(uebKey)))
955 portalRestResponse = externalAccessRolesController.bulkUploadRoleFunctions(mockedRequest, mockedResponse);
956 assertEquals(portalRestResponse, expectedportalRestResponse);
960 public void bulkUploadRoleFunctionsException() throws Exception {
961 Mockito.when(externalAccessRolesService.bulkUploadRolesFunctions(mockedRequest.getHeader(uebKey)))
962 .thenThrow(httpClientErrorException);
963 PortalRestResponse<String> portalRestResponse = null;
964 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
965 expectedportalRestResponse.setMessage("Failed to bulkUploadRoleFunctions");
966 expectedportalRestResponse.setResponse("Failed");
967 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
968 portalRestResponse = externalAccessRolesController.bulkUploadRoleFunctions(mockedRequest, mockedResponse);
969 assertEquals(portalRestResponse, expectedportalRestResponse);
973 public void bulkUploadUserRolesTest() throws Exception {
975 PortalRestResponse<String> portalRestResponse = null;
976 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
977 expectedportalRestResponse.setMessage("Successfully added: 0");
978 expectedportalRestResponse.setResponse("Success");
979 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
980 Mockito.when(externalAccessRolesService.bulkUploadUserRoles(mockedRequest.getHeader(uebKey)))
982 portalRestResponse = externalAccessRolesController.bulkUploadUserRoles(mockedRequest, mockedResponse);
983 assertEquals(portalRestResponse, expectedportalRestResponse);
987 public void bulkUploadUserRolesExceptionTest() throws Exception {
988 Mockito.when(externalAccessRolesService.bulkUploadUserRoles(mockedRequest.getHeader(uebKey)))
989 .thenThrow(httpClientErrorException);
990 PortalRestResponse<String> portalRestResponse = null;
991 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
992 expectedportalRestResponse.setMessage("Failed to bulkUploadUserRoles");
993 expectedportalRestResponse.setResponse("Failed");
994 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
995 portalRestResponse = externalAccessRolesController.bulkUploadUserRoles(mockedRequest, mockedResponse);
996 assertEquals(portalRestResponse, expectedportalRestResponse);
1000 public void bulkUploadPartnerFunctionsTest() {
1001 PortalRestResponse<String> portalRestResponse = null;
1002 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1003 expectedportalRestResponse.setMessage("Successfully added: '0' functions");
1004 expectedportalRestResponse.setResponse("Success");
1005 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
1006 portalRestResponse = externalAccessRolesController.bulkUploadPartnerFunctions(mockedRequest, mockedResponse);
1007 assertEquals(portalRestResponse, expectedportalRestResponse);
1011 public void bulkUploadPartnerRolesTest() {
1012 PortalRestResponse<String> portalRestResponse = null;
1013 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1014 expectedportalRestResponse.setMessage("Successfully added");
1015 expectedportalRestResponse.setResponse("Success");
1016 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
1017 List<Role> upload = new ArrayList<>();
1018 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoles(mockedRequest, mockedResponse,
1020 assertEquals(portalRestResponse, expectedportalRestResponse);
1024 public void bulkUploadPartnerRolesExceptionTest() {
1025 PortalRestResponse<String> portalRestResponse = null;
1026 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1027 expectedportalRestResponse.setMessage("Successfully added");
1028 expectedportalRestResponse.setResponse("Success");
1029 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
1030 List<Role> upload = new ArrayList<>();
1031 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoles(mockedRequest, mockedResponse,
1033 assertEquals(portalRestResponse, expectedportalRestResponse);
1037 public void getMenuFunctionsTest() throws Exception {
1038 String reason = getInvalidKeyJson();
1039 StringWriter sw = new StringWriter();
1040 PrintWriter writer = new PrintWriter(sw);
1041 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
1042 Mockito.when(externalAccessRolesService.getMenuFunctionsList(mockedRequest.getHeader(uebKey))).thenReturn(null);
1043 List<String> expectedFunctionsList = externalAccessRolesController.getMenuFunctions(mockedRequest,
1045 assertNull(expectedFunctionsList);
1046 String result = sw.getBuffer().toString().trim();
1047 assertEquals(reason, result);
1051 public void getMenuFunctionsExceptionTest() throws Exception {
1052 String reason = getInvalidKeyJson();
1053 StringWriter sw = new StringWriter();
1054 PrintWriter writer = new PrintWriter(sw);
1055 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
1056 Mockito.when(externalAccessRolesService.getMenuFunctionsList(mockedRequest.getHeader(uebKey)))
1057 .thenThrow(httpClientErrorException);
1058 assertNull(externalAccessRolesController.getMenuFunctions(mockedRequest, mockedResponse));
1059 String result = sw.getBuffer().toString().trim();
1060 assertEquals(reason, result);
1064 public void saveRoleExceptionTest() {
1065 Role role = new Role();
1066 PortalRestResponse<String> portalRestResponse = null;
1067 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1068 expectedportalRestResponse.setMessage("Invalid credentials!");
1069 expectedportalRestResponse.setResponse("Failed");
1070 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1071 portalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse, role);
1072 assertEquals(portalRestResponse, expectedportalRestResponse);
1076 public void deleteRoleExceptionTest() {
1077 String role = "TestNew";
1078 PortalRestResponse<String> portalRestResponse = null;
1079 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1080 expectedportalRestResponse.setMessage("Invalid credentials!");
1081 expectedportalRestResponse.setResponse("Failed");
1082 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1083 portalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, role);
1084 assertEquals(portalRestResponse, expectedportalRestResponse);
1088 public void bulkUploadPartnerRoleFunctionsTest() {
1089 PortalRestResponse<String> portalRestResponse = null;
1090 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1091 expectedportalRestResponse.setMessage("Successfully added: '0' role functions");
1092 expectedportalRestResponse.setResponse("Success");
1093 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
1094 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoleFunctions(mockedRequest,
1096 assertEquals(portalRestResponse, expectedportalRestResponse);
1100 public void getUsersOfApplicationTest() throws Exception {
1101 List<EcompUser> users = new ArrayList<>();
1102 EcompUser user = new EcompUser();
1103 user.setOrgUserId("guestT");
1105 StringWriter sw = new StringWriter();
1106 PrintWriter writer = new PrintWriter(sw);
1107 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
1108 List<EPApp> applicationList = new ArrayList<>();
1109 EPApp app = mockApp();
1110 app.setCentralAuth(true);
1111 applicationList.add(app);
1112 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1113 Mockito.when(externalAccessRolesService.getAllAppUsers(mockedRequest.getHeader(uebKey))).thenReturn(users);
1114 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
1115 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
1116 List<EcompUser> expectedUsers = externalAccessRolesController.getUsersOfApplication(mockedRequest,
1118 assertEquals(expectedUsers, users);
1121 @Test(expected = Exception.class)
1122 public void getUsersOfApplicationExceptionTest() throws Exception {
1123 List<EcompUser> users = new ArrayList<>();
1124 EcompUser user = new EcompUser();
1125 user.setOrgUserId("guestT");
1127 Mockito.when(externalAccessRolesService.getAllAppUsers(mockedRequest.getHeader(uebKey)))
1128 .thenThrow(nullPointerException);
1129 assertNull(externalAccessRolesController.getUsersOfApplication(mockedRequest, mockedResponse));
1132 @Test(expected = NullPointerException.class)
1133 public void deleteRoleV2Test() throws Exception {
1134 List<EPApp> applicationList = new ArrayList<>();
1135 EPApp app = mockApp();
1136 applicationList.add(app);
1137 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1138 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(true,
1140 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(), Matchers.anyString(),
1141 Matchers.anyString())).thenReturn(externalRequestFieldsValidator);
1142 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1143 expectedportalRestResponse.setMessage("Successfully Deleted");
1144 expectedportalRestResponse.setResponse("Success");
1145 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
1146 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest,
1147 mockedResponse, (long) 1);
1148 assertNull(actualResponse);
1152 public void deleteRoleV2InvalidUebKeyTest() throws Exception {
1153 List<EPApp> applicationList = new ArrayList<>();
1154 EPApp app = mockApp();
1155 applicationList.add(app);
1156 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey)))
1157 .thenThrow(new Exception("Invalid credentials!"));
1158 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1159 expectedportalRestResponse.setMessage("Invalid credentials!");
1160 expectedportalRestResponse.setResponse("Failed");
1161 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1162 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest,
1163 mockedResponse, (long) 1);
1164 assertEquals(actualResponse, expectedportalRestResponse);
1168 public void deleteRoleV2InvalidUebKeyWithDiffErrorTest() throws Exception {
1169 List<EPApp> applicationList = new ArrayList<>();
1170 EPApp app = mockApp();
1171 applicationList.add(app);
1172 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey)))
1173 .thenThrow(new Exception("test"));
1174 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1175 expectedportalRestResponse.setMessage("test");
1176 expectedportalRestResponse.setResponse("Failed");
1177 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1178 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest,
1179 mockedResponse, (long) 1);
1180 assertEquals(actualResponse, expectedportalRestResponse);
1183 @Test(expected = NullPointerException.class)
1184 public void deleteRoleV2ExceptionTest() throws Exception {
1185 List<EPApp> applicationList = new ArrayList<>();
1186 EPApp app = mockApp();
1187 applicationList.add(app);
1188 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1189 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false,
1191 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(), Matchers.anyString(),
1192 Matchers.anyString())).thenReturn(externalRequestFieldsValidator);
1193 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1194 expectedportalRestResponse.setMessage("Failed to deleteRole");
1195 expectedportalRestResponse.setResponse("Failed");
1196 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1197 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest,
1198 mockedResponse, (long) 1);
1199 assertEquals(actualResponse, null);
1203 public void getEpUserNullTest() throws Exception {
1204 List<EPApp> applicationList = new ArrayList<>();
1205 EPApp app = mockApp();
1206 app.setUebKey("uebKey");
1207 app.setCentralAuth(true);
1208 applicationList.add(app);
1209 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1210 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
1211 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
1212 externalAccessRolesController.getEcompUser(mockedRequest, mockedResponse, "test12");
1216 public void getEpUserTest() throws Exception {
1217 List<EPApp> applicationList = new ArrayList<>();
1218 EPApp app = mockApp();
1219 app.setUebKey("uebKey");
1220 app.setCentralAuth(true);
1221 applicationList.add(app);
1222 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1223 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
1224 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
1225 String user = "{\"id\":null,\"created\":null,\"modified\":null,\"createdId\":null,\"modifiedId\":null,\"rowNum\":null,\"auditUserId\":null,\"auditTrail\":null,\"orgId\":null,\"managerId\":null,\"firstName\":\"test\",\"middleInitial\":null,\"lastName\":null,\"phone\":null,\"fax\":null,\"cellular\":null,\"email\":null,\"addressId\":null,\"alertMethodCd\":null,\"hrid\":null,\"orgUserId\":null,\"orgCode\":null,\"address1\":null,\"address2\":null,\"city\":null,\"state\":null,\"zipCode\":null,\"country\":null,\"orgManagerUserId\":null,\"locationClli\":null,\"businessCountryCode\":null,\"businessCountryName\":null,\"businessUnit\":null,\"businessUnitName\":null,\"department\":null,\"departmentName\":null,\"companyCode\":null,\"company\":null,\"zipCodeSuffix\":null,\"jobTitle\":null,\"commandChain\":null,\"siloStatus\":null,\"costCenter\":null,\"financialLocCode\":null,\"loginId\":null,\"loginPwd\":null,\"lastLoginDate\":null,\"active\":false,\"internal\":false,\"selectedProfileId\":null,\"timeZoneId\":null,\"online\":false,\"chatId\":null,\"userApps\":[],\"pseudoRoles\":[],\"roles\":[]}";
1226 Mockito.when(externalAccessRolesService.getV2UserWithRoles("test12", mockedRequest.getHeader(uebKey)))
1228 User EPuser = new User();
1229 EPuser.setFirstName("test");
1230 Mockito.when(userservice.userMapper(user)).thenReturn(EPuser);
1231 String res = "{\"orgId\":null,\"managerId\":null,\"firstName\":\"test\",\"middleInitial\":null,\"lastName\":null,\"phone\":null,\"email\":null,\"hrid\":null,\"orgUserId\":null,\"orgCode\":null,\"orgManagerUserId\":null,\"jobTitle\":null,\"loginId\":null,\"active\":false,\"roles\":[]}";
1232 assertEquals(externalAccessRolesController.getEcompUser(mockedRequest, mockedResponse, "test12"), res);
1236 public void getEpUserExceptionTest() throws Exception {
1237 List<EPApp> applicationList = new ArrayList<>();
1238 EPApp app = mockApp();
1239 app.setCentralAuth(true);
1240 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1241 StringWriter sw = new StringWriter();
1242 PrintWriter writer = new PrintWriter(sw);
1243 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
1244 externalAccessRolesController.getEcompUser(mockedRequest, mockedResponse, "test12");
1248 public void getEPRolesOfApplicationTest() throws Exception {
1249 List<EPApp> applicationList = new ArrayList<>();
1250 EPApp app = mockApp();
1251 app.setUebKey("uebKey");
1252 app.setCentralAuth(true);
1253 applicationList.add(app);
1254 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1255 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
1256 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
1257 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
1258 List<CentralV2Role> cenRoleList = new ArrayList<>();
1259 CentralV2Role role = new CentralV2Role();
1260 role.setName("test");
1261 cenRoleList.add(role);
1262 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey)))
1263 .thenReturn(cenRoleList);
1264 List<EcompRole> ecompRoles = new ArrayList<>();
1265 EcompRole eprole = new EcompRole();
1266 eprole.setName("test");
1267 ecompRoles.add(eprole);
1268 assertEquals(ecompRoles,
1269 externalAccessRolesController.getEcompRolesOfApplication(mockedRequest, mockedResponse));
1273 public void getEPRolesOfApplicationNullTest() throws Exception {
1274 List<EPApp> applicationList = new ArrayList<>();
1275 EPApp app = mockApp();
1276 app.setUebKey("uebKey");
1277 app.setCentralAuth(true);
1278 applicationList.add(app);
1279 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1280 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
1281 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
1282 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
1283 List<CentralV2Role> cenRoleList = new ArrayList<>();
1284 CentralV2Role role = new CentralV2Role();
1285 role.setName("test");
1286 cenRoleList.add(role);
1287 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey))).thenReturn(null);
1288 assertNull(externalAccessRolesController.getEcompRolesOfApplication(mockedRequest, mockedResponse));
1292 public void getEPRolesOfApplicationExceptionTest() throws Exception {
1293 List<EPApp> applicationList = new ArrayList<>();
1294 EPApp app = mockApp();
1295 app.setCentralAuth(true);
1296 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1297 StringWriter sw = new StringWriter();
1298 PrintWriter writer = new PrintWriter(sw);
1299 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
1300 assertNull(externalAccessRolesController.getEcompRolesOfApplication(mockedRequest, mockedResponse));
1304 public void saveRoleTest() throws Exception {
1305 PowerMockito.mockStatic(EcompPortalUtils.class);
1306 PowerMockito.mockStatic(SystemProperties.class);
1307 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1308 PowerMockito.mockStatic(PortalConstants.class);
1309 PortalRestResponse<String> actualPortalRestResponse = null;
1310 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1311 expectedportalRestResponse.setMessage("Successfully Saved");
1312 expectedportalRestResponse.setResponse("Success");
1313 EPUser user = mockUser.mockEPUser();
1314 List<EPUser> userList = new ArrayList<>();
1316 EPApp app = mockApp();
1317 app.setCentralAuth(true);
1318 List<EPApp> appList = new ArrayList<>();
1320 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
1321 Role role = new Role();
1322 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(true,
1324 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1325 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1326 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1327 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1328 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1329 Mockito.when(externalAccessRolesService.saveRoleForApplication(role, mockedRequest.getHeader("uebkey")))
1330 .thenReturn(externalRequestFieldsValidator);
1331 actualPortalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse, role);
1332 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1336 public void saveRoleNegativeTest() throws Exception {
1337 PowerMockito.mockStatic(EcompPortalUtils.class);
1338 PowerMockito.mockStatic(SystemProperties.class);
1339 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1340 PowerMockito.mockStatic(PortalConstants.class);
1341 PortalRestResponse<String> actualPortalRestResponse = null;
1342 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1343 expectedportalRestResponse.setMessage("Successfully Saved");
1344 expectedportalRestResponse.setResponse("Success");
1345 EPUser user = mockUser.mockEPUser();
1346 List<EPUser> userList = new ArrayList<>();
1348 EPApp app = mockApp();
1349 app.setCentralAuth(true);
1350 List<EPApp> appList = new ArrayList<>();
1352 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1353 Role role = new Role();
1354 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false,
1356 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1357 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1358 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1359 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1360 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1361 Mockito.when(externalAccessRolesService.saveRoleForApplication(role, mockedRequest.getHeader("uebkey")))
1362 .thenReturn(externalRequestFieldsValidator);
1363 actualPortalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse, role);
1364 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1368 public void saveRole406Test() throws Exception {
1369 PowerMockito.mockStatic(EcompPortalUtils.class);
1370 PowerMockito.mockStatic(SystemProperties.class);
1371 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1372 PowerMockito.mockStatic(PortalConstants.class);
1373 PortalRestResponse<String> actualPortalRestResponse = null;
1374 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1375 expectedportalRestResponse.setMessage("Successfully Saved");
1376 expectedportalRestResponse.setResponse("Failed");
1377 EPUser user = mockUser.mockEPUser();
1378 List<EPUser> userList = new ArrayList<>();
1380 EPApp app = mockApp();
1381 app.setCentralAuth(true);
1382 List<EPApp> appList = new ArrayList<>();
1384 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1385 Role role = new Role();
1386 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false,
1388 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1389 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1390 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1391 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1392 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1393 Mockito.when(externalAccessRolesService.saveRoleForApplication(role, mockedRequest.getHeader("uebkey")))
1394 .thenReturn(externalRequestFieldsValidator);
1395 actualPortalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse, role);
1396 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1399 @Test(expected = NullPointerException.class)
1400 public void saveRoleNullExceptionTest() throws Exception {
1401 List<EPApp> applicationList = new ArrayList<>();
1402 EPApp app = mockApp();
1403 applicationList.add(app);
1404 Role role = new Role();
1405 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1406 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false,
1408 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(), Matchers.anyString(),
1409 Matchers.anyString())).thenReturn(externalRequestFieldsValidator);
1410 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1411 expectedportalRestResponse.setMessage("Failed to deleteRole");
1412 expectedportalRestResponse.setResponse("Failed");
1413 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1414 PortalRestResponse<String> actualResponse = externalAccessRolesController.saveRole(mockedRequest,
1415 mockedResponse, role);
1416 assertEquals(actualResponse, null);
1420 public void deleteRoleTest() throws Exception {
1421 PowerMockito.mockStatic(EcompPortalUtils.class);
1422 PowerMockito.mockStatic(SystemProperties.class);
1423 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1424 PowerMockito.mockStatic(PortalConstants.class);
1425 PortalRestResponse<String> actualPortalRestResponse = null;
1426 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1427 expectedportalRestResponse.setMessage("Successfully Deleted");
1428 expectedportalRestResponse.setResponse("Success");
1429 EPUser user = mockUser.mockEPUser();
1430 List<EPUser> userList = new ArrayList<>();
1432 EPApp app = mockApp();
1433 app.setCentralAuth(true);
1434 List<EPApp> appList = new ArrayList<>();
1436 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
1437 String code = "test";
1438 boolean deleteResponse = true;
1439 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1440 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1441 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1442 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1443 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1444 Mockito.when(externalAccessRolesService.deleteRoleForApplication(code, mockedRequest.getHeader("uebkey")))
1445 .thenReturn(deleteResponse);
1446 actualPortalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, code);
1447 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1451 public void deleteRoleXSSTest() throws Exception {
1452 PowerMockito.mockStatic(EcompPortalUtils.class);
1453 PowerMockito.mockStatic(SystemProperties.class);
1454 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1455 PowerMockito.mockStatic(PortalConstants.class);
1456 PortalRestResponse<String> actualPortalRestResponse = null;
1457 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1458 expectedportalRestResponse.setMessage("Failed to deleteRole, not valid data.");
1459 expectedportalRestResponse.setResponse("Failed");
1460 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1461 EPUser user = mockUser.mockEPUser();
1462 List<EPUser> userList = new ArrayList<>();
1464 EPApp app = mockApp();
1465 app.setCentralAuth(true);
1466 List<EPApp> appList = new ArrayList<>();
1468 String code = "<img src=xss onerror=alert(1)>";
1469 boolean deleteResponse = true;
1470 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1471 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1472 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1473 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1474 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1475 Mockito.when(externalAccessRolesService.deleteRoleForApplication(code, mockedRequest.getHeader("uebkey")))
1476 .thenReturn(deleteResponse);
1477 actualPortalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, code);
1478 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1482 public void deleteRoleNegativeTest() throws Exception {
1483 PowerMockito.mockStatic(EcompPortalUtils.class);
1484 PowerMockito.mockStatic(SystemProperties.class);
1485 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1486 PowerMockito.mockStatic(PortalConstants.class);
1487 PortalRestResponse<String> actualPortalRestResponse = null;
1488 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1489 expectedportalRestResponse.setMessage("Failed to delete Role for 'test");
1490 expectedportalRestResponse.setResponse("Failed");
1491 EPUser user = mockUser.mockEPUser();
1492 List<EPUser> userList = new ArrayList<>();
1494 EPApp app = mockApp();
1495 app.setCentralAuth(true);
1496 List<EPApp> appList = new ArrayList<>();
1498 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1499 String code = "test";
1500 boolean deleteResponse = false;
1501 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1502 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1503 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1504 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1505 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1506 Mockito.when(externalAccessRolesService.deleteRoleForApplication(code, mockedRequest.getHeader("uebkey")))
1507 .thenReturn(deleteResponse);
1508 actualPortalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, code);
1509 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1513 public void deleteDependcyRoleRecordTest() throws Exception {
1514 ExternalRequestFieldsValidator removeResult = new ExternalRequestFieldsValidator(true, "success");
1515 PortalRestResponse<String> portalRestResponse = null;
1516 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1517 expectedportalRestResponse.setMessage("Invalid credentials!");
1518 expectedportalRestResponse.setResponse("Failed");
1519 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1521 String LoginId = "loginId";
1522 List<EPApp> appList = new ArrayList<>();
1523 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1524 Mockito.when(mockedRequest.getHeader("LoginId")).thenReturn(LoginId);
1525 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1526 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(roleId, mockedRequest.getHeader("uebkey"),
1527 mockedRequest.getHeader("LoginId"))).thenReturn(removeResult);
1528 portalRestResponse = externalAccessRolesController.deleteDependencyRoleRecord(mockedRequest, mockedResponse,
1530 assertEquals(expectedportalRestResponse, portalRestResponse);