2 * ============LICENSE_START==========================================
4 * ===================================================================
5 * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
6 * ===================================================================
7 * Modifications Copyright (c) 2019 Samsung
8 * ===================================================================
10 * Unless otherwise specified, all software contained herein is licensed
11 * under the Apache License, Version 2.0 (the "License");
12 * you may not use this software except in compliance with the License.
13 * You may obtain a copy of the License at
15 * http://www.apache.org/licenses/LICENSE-2.0
17 * Unless required by applicable law or agreed to in writing, software
18 * distributed under the License is distributed on an "AS IS" BASIS,
19 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
20 * See the License for the specific language governing permissions and
21 * limitations under the License.
23 * Unless otherwise specified, all documentation contained herein is licensed
24 * under the Creative Commons License, Attribution 4.0 Intl. (the "License");
25 * you may not use this documentation except in compliance with the License.
26 * You may obtain a copy of the License at
28 * https://creativecommons.org/licenses/by/4.0/
30 * Unless required by applicable law or agreed to in writing, documentation
31 * distributed under the License is distributed on an "AS IS" BASIS,
32 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
33 * See the License for the specific language governing permissions and
34 * limitations under the License.
36 * ============LICENSE_END============================================
40 package org.onap.portalapp.portal.controller;
42 import static org.junit.Assert.assertEquals;
43 import static org.junit.Assert.assertNull;
44 import java.io.BufferedReader;
45 import java.io.ByteArrayInputStream;
46 import java.io.IOException;
47 import java.io.PrintWriter;
48 import java.io.StringReader;
49 import java.io.StringWriter;
50 import java.nio.charset.StandardCharsets;
51 import java.util.ArrayList;
52 import java.util.HashMap;
53 import java.util.List;
55 import java.util.SortedSet;
56 import java.util.TreeSet;
57 import javax.servlet.http.HttpServletRequest;
58 import javax.servlet.http.HttpServletResponse;
59 import org.json.simple.JSONObject;
60 import org.junit.Before;
61 import org.junit.Test;
62 import org.junit.runner.RunWith;
63 import org.mockito.InjectMocks;
64 import org.mockito.Matchers;
65 import org.mockito.Mock;
66 import org.mockito.Mockito;
67 import org.mockito.MockitoAnnotations;
68 import org.onap.portalapp.controller.core.RoleController;
69 import org.onap.portalapp.controller.core.RoleFunctionListController;
70 import org.onap.portalapp.controller.core.RoleListController;
71 import org.onap.portalapp.portal.core.MockEPUser;
72 import org.onap.portalapp.portal.domain.CentralV2RoleFunction;
73 import org.onap.portalapp.portal.domain.CentralizedApp;
74 import org.onap.portalapp.portal.domain.EPApp;
75 import org.onap.portalapp.portal.domain.EPUser;
76 import org.onap.portalapp.portal.ecomp.model.PortalRestResponse;
77 import org.onap.portalapp.portal.ecomp.model.PortalRestStatusEnum;
78 import org.onap.portalapp.portal.ecomp.model.UploadRoleFunctionExtSystem;
79 import org.onap.portalapp.portal.framework.MockitoTestSuite;
80 import org.onap.portalapp.portal.service.AdminRolesService;
81 import org.onap.portalapp.portal.service.EPAppService;
82 import org.onap.portalapp.portal.service.ExternalAccessRolesService;
83 import org.onap.portalapp.portal.transport.CentralV2Role;
84 import org.onap.portalapp.portal.transport.ExternalRequestFieldsValidator;
85 import org.onap.portalapp.portal.utils.EcompPortalUtils;
86 import org.onap.portalapp.util.EPUserUtils;
87 import org.onap.portalsdk.core.domain.Role;
88 import org.onap.portalsdk.core.service.AuditService;
89 import org.powermock.api.mockito.PowerMockito;
90 import org.powermock.core.classloader.annotations.PrepareForTest;
91 import org.powermock.modules.junit4.PowerMockRunner;
92 import org.springframework.http.HttpStatus;
93 import org.springframework.http.ResponseEntity;
94 import org.springframework.mock.web.DelegatingServletInputStream;
95 import org.springframework.web.servlet.ModelAndView;
96 import com.fasterxml.jackson.databind.JsonNode;
97 import com.fasterxml.jackson.databind.ObjectMapper;
99 @RunWith(PowerMockRunner.class)
100 @PrepareForTest({ EPUserUtils.class, EcompPortalUtils.class })
101 public class RoleManageControllerTest {
104 RoleController roleController;
107 RoleListController roleListController;
110 RoleFunctionListController roleFunctionListController;
113 ExternalAccessRolesService externalAccessRolesService;
115 EPUserUtils ePUserUtils = new EPUserUtils();
118 ExternalAccessRolesService externalAccessRolesService1 = null;
121 RoleManageController roleManageController = new RoleManageController();
124 EPAppService appService;
127 AuditService auditService;
130 AdminRolesService adminRolesService;
133 public void setup() {
134 MockitoAnnotations.initMocks(this);
137 MockitoTestSuite mockitoTestSuite = new MockitoTestSuite();
139 HttpServletRequest mockedRequest = mockitoTestSuite.getMockedRequest();
140 HttpServletResponse mockedResponse = mockitoTestSuite.getMockedResponse();
141 NullPointerException nullPointerException = new NullPointerException();
142 MockEPUser mockUser = new MockEPUser();
144 private DelegatingServletInputStream dsi;
147 public void removeRoleRoleFunctionTest() throws Exception {
149 ModelAndView modelandView = new ModelAndView("login.htm");
150 Mockito.when(roleController.removeRoleFunction(mockedRequest, mockedResponse)).thenReturn(modelandView);
151 ModelAndView expectedModelandView = roleManageController.removeRoleRoleFunction(mockedRequest, mockedResponse);
152 assertEquals(expectedModelandView, modelandView);
156 public void addRoleRoRoleFunctionTest() throws Exception {
157 ModelAndView modelandView = new ModelAndView("login.htm");
158 Mockito.when(roleController.addRoleFunction(mockedRequest, mockedResponse)).thenReturn(modelandView);
159 ModelAndView expectedModelandView = roleManageController.addRoleRoRoleFunction(mockedRequest, mockedResponse);
160 assertEquals(expectedModelandView, modelandView);
164 public void removeChildRoleTest() throws Exception {
165 ModelAndView modelandView = new ModelAndView("login.htm");
166 Mockito.when(roleController.removeChildRole(mockedRequest, mockedResponse)).thenReturn(modelandView);
167 ModelAndView expectedModelandView = roleManageController.removeChildRole(mockedRequest, mockedResponse);
168 assertEquals(expectedModelandView, modelandView);
172 public void getRoleIfRoleIdNullTest() throws Exception {
173 PowerMockito.mockStatic(EPUserUtils.class);
174 PowerMockito.mockStatic(EcompPortalUtils.class);
175 EPUser user = mockUser.mockEPUser();
176 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
177 Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true);
178 Mockito.when(appService.getApp((long) 1)).thenReturn(CentralApp());
179 Mockito.when(adminRolesService.isAccountAdminOfApplication(user, CentralApp())).thenReturn(true);
180 List<EPApp> apps = new ArrayList<>();
181 apps.add(CentralApp());
182 Mockito.when(externalAccessRolesService.getApp(CentralApp().getUebKey())).thenReturn(apps);
183 ResponseEntity<String> result = new ResponseEntity<>(HttpStatus.OK);
184 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(apps.get(0))).thenReturn(result);
185 CentralV2Role answer = new CentralV2Role.CentralV2RoleBuilder().createCentralV2Role();
186 Mockito.when(externalAccessRolesService.getRoleInfo((long) 1, "test")).thenReturn(answer);
187 List<CentralV2RoleFunction> finalRoleFunctionList = new ArrayList<>();
188 Mockito.when(externalAccessRolesService.getRoleFuncList("test")).thenReturn(finalRoleFunctionList);
189 Mockito.when(externalAccessRolesService.getRolesForApp("test")).thenReturn(null);
190 StringWriter sw = new StringWriter();
191 PrintWriter writer = new PrintWriter(sw);
192 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
193 List<EPApp> appList = new ArrayList<>();
194 appList.add(CentralApp());
195 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
196 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(Matchers.anyObject())).thenReturn(response);
197 Mockito.when(externalAccessRolesService.getApp(Matchers.anyString())).thenReturn(appList);
198 roleManageController.getRole(mockedRequest, mockedResponse, (long) 1, null);
201 @Test(expected = Exception.class)
202 public void getRoleExceptionTest() throws Exception {
203 Mockito.when(appService.getApp((long) 1)).thenReturn(mockApp());
204 CentralV2Role answer = new CentralV2Role.CentralV2RoleBuilder().createCentralV2Role();
205 Mockito.when(externalAccessRolesService.getRoleInfo((long) 1, "test")).thenReturn(answer);
206 Mockito.when(externalAccessRolesService.getRoleFuncList("test")).thenThrow(nullPointerException);
207 roleManageController.getRole(mockedRequest, mockedResponse, (long) 1, null);
212 public void getRoleIfRoleIdNotNullTest() throws Exception {
213 Mockito.when(appService.getApp((long) 1)).thenReturn(CentralApp());
214 CentralV2Role answer = new CentralV2Role.CentralV2RoleBuilder().createCentralV2Role();
215 Mockito.when(externalAccessRolesService.getRoleInfo((long) 1, "test")).thenReturn(answer);
216 List<CentralV2RoleFunction> finalRoleFunctionList = new ArrayList<>();
217 Mockito.when(externalAccessRolesService.getRoleFuncList("test")).thenReturn(finalRoleFunctionList);
218 StringWriter sw = new StringWriter();
219 PrintWriter writer = new PrintWriter(sw);
220 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
221 CentralV2Role currentRole = new CentralV2Role.CentralV2RoleBuilder().createCentralV2Role();
222 SortedSet<CentralV2Role> parentRoles = new TreeSet<>();
223 CentralV2Role centralV2Role = new CentralV2Role.CentralV2RoleBuilder().createCentralV2Role();
224 centralV2Role.setName("test");
225 parentRoles.add(centralV2Role);
226 currentRole.setParentRoles(parentRoles);
227 Mockito.when(externalAccessRolesService.getRoleInfo((long) 1, "test")).thenReturn(currentRole);
228 List<CentralV2Role> availableChildRoles = new ArrayList<>();
229 availableChildRoles.add(currentRole);
230 Mockito.when(externalAccessRolesService.getRolesForApp("test")).thenReturn(availableChildRoles);
231 List<EPApp> appList = new ArrayList<>();
232 appList.add(CentralApp());
233 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
234 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(Matchers.anyObject())).thenReturn(response);
235 Mockito.when(externalAccessRolesService.getApp(Matchers.anyString())).thenReturn(appList);
236 roleManageController.getRole(mockedRequest, mockedResponse, (long) 1, (long) 1);
239 public EPApp mockApp() {
240 EPApp app = new EPApp();
243 app.setImageUrl("test");
244 app.setDescription("test");
245 app.setNotes("test");
248 app.setAppRestEndpoint("test");
249 app.setAlternateUrl("test");
251 app.setMlAppName("test");
252 app.setMlAppAdminId("test");
253 app.setUsername("test");
254 app.setAppPassword("test");
256 app.setEnabled(false);
257 app.setUebKey("test");
258 app.setUebSecret("test");
259 app.setUebTopicName("test");
266 public void getRolesTest() throws Exception {
267 EPApp app = mockApp();
268 app.setCentralAuth(true);
269 PowerMockito.mockStatic(EPUserUtils.class);
270 PowerMockito.mockStatic(EcompPortalUtils.class);
271 EPUser user = mockUser.mockEPUser();
272 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
273 Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true);
274 Mockito.when(appService.getApp((long) 1)).thenReturn(app);
275 Mockito.when(adminRolesService.isAccountAdminOfApplication(user, app)).thenReturn(true);
276 List<CentralV2Role> answer = new ArrayList<>();
277 Mockito.when(appService.getApp((long) 1)).thenReturn(app);
278 Mockito.when(externalAccessRolesService.getRolesForApp("test")).thenReturn(answer);
279 StringWriter sw = new StringWriter();
280 PrintWriter writer = new PrintWriter(sw);
281 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
282 List<EPApp> appList = new ArrayList<>();
283 appList.add(CentralApp());
284 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
285 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(Matchers.anyObject())).thenReturn(response);
286 Mockito.when(externalAccessRolesService.getApp(Matchers.anyString())).thenReturn(appList);
287 roleManageController.getRoles(mockedRequest, mockedResponse, (long) 1);
291 public void getRolesExceptionTest() throws Exception {
292 EPApp app = CentralApp();
293 Mockito.when(appService.getApp((long) 1)).thenReturn(app);
294 Mockito.when(externalAccessRolesService.getRolesForApp("test")).thenThrow(new java.lang.Exception());
295 roleManageController.getRoles(mockedRequest, mockedResponse, (long) 1);
300 public void getRoleFunctionListTest() throws Exception {
301 PowerMockito.mockStatic(EPUserUtils.class);
302 PowerMockito.mockStatic(EcompPortalUtils.class);
303 EPUser user = mockUser.mockEPUser();
304 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
305 Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true);
306 Mockito.when(adminRolesService.isAccountAdminOfApplication(user, CentralApp())).thenReturn(true);
307 Mockito.when(appService.getApp((long) 1)).thenReturn(CentralApp());
308 List<CentralV2RoleFunction> answer = new ArrayList<>();
309 Mockito.when(externalAccessRolesService.getRoleFuncList("test")).thenReturn(answer);
310 StringWriter sw = new StringWriter();
311 PrintWriter writer = new PrintWriter(sw);
312 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
313 List<EPApp> appList = new ArrayList<>();
314 appList.add(CentralApp());
315 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
316 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(Matchers.anyObject())).thenReturn(response);
317 Mockito.when(externalAccessRolesService.getApp(Matchers.anyString())).thenReturn(appList);
318 roleManageController.getRoleFunctionList(mockedRequest, mockedResponse, (long) 1);
321 @Test(expected = Exception.class)
322 public void getRoleFunctionListExceptionTest() throws Exception {
323 Mockito.when(appService.getApp((long) 1)).thenReturn(NonCentralApp());
324 roleManageController.getRoleFunctionList(mockedRequest, mockedResponse, (long) 1);
328 public void saveRoleFunctionTest() throws Exception {
329 PowerMockito.mockStatic(EPUserUtils.class);
330 PowerMockito.mockStatic(EcompPortalUtils.class);
331 EPUser user = mockUser.mockEPUser();
332 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
333 Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true);
334 Mockito.when(adminRolesService.isAccountAdminOfApplication(user, CentralApp())).thenReturn(true);
335 Mockito.when(appService.getApp((long) 1)).thenReturn(CentralApp());
336 Mockito.doNothing().when(roleFunctionListController).saveRoleFunction(mockedRequest, mockedResponse, "test");
337 CentralV2RoleFunction addNewFunc = new CentralV2RoleFunction();
338 addNewFunc.setCode("Test");
339 addNewFunc.setType("Test");
340 addNewFunc.setAction("Test");
341 addNewFunc.setName("Test");
342 CentralV2RoleFunction roleFunction = mockCentralRoleFunction();
343 roleFunction.setCode("Test|Test|Test");
344 Mockito.when(externalAccessRolesService.getRoleFunction("Test|Test|Test", "test")).thenReturn(roleFunction);
345 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(Matchers.anyObject(), Matchers.anyObject()))
347 Mockito.when(EcompPortalUtils.getFunctionCode(roleFunction.getCode())).thenReturn("Test");
348 Mockito.when(EcompPortalUtils.getFunctionType(roleFunction.getCode())).thenReturn("Test");
349 Mockito.when(EcompPortalUtils.getFunctionAction(roleFunction.getCode())).thenReturn("Test");
350 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
351 List<EPUser> userList = new ArrayList<>();
353 List<EPApp> appList = new ArrayList<>();
354 appList.add(CentralApp());
355 Mockito.when(externalAccessRolesService.getUser("guestT")).thenReturn(userList);
356 StringWriter sw = new StringWriter();
357 PrintWriter writer = new PrintWriter(sw);
358 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
359 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
360 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(Matchers.anyObject())).thenReturn(response);
361 Mockito.when(externalAccessRolesService.getApp(Matchers.anyString())).thenReturn(appList);
362 PortalRestResponse<String> actual = roleManageController.saveRoleFunction(mockedRequest, mockedResponse,
363 addNewFunc, (long) 1);
364 PortalRestResponse<String> expected = new PortalRestResponse<String>(PortalRestStatusEnum.OK,
365 "Saved Successfully!", "Success");
366 assertEquals(expected, actual);
370 public void saveRoleFunctionXSSTest() throws Exception {
371 PowerMockito.mockStatic(EPUserUtils.class);
372 PowerMockito.mockStatic(EcompPortalUtils.class);
373 EPUser user = mockUser.mockEPUser();
374 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
375 Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true);
376 Mockito.when(adminRolesService.isAccountAdminOfApplication(user, CentralApp())).thenReturn(true);
377 Mockito.when(appService.getApp((long) 1)).thenReturn(CentralApp());
378 Mockito.doNothing().when(roleFunctionListController).saveRoleFunction(mockedRequest, mockedResponse, "test");
379 CentralV2RoleFunction addNewFunc = new CentralV2RoleFunction();
380 addNewFunc.setCode("“><script>alert(“XSS”)</script>");
381 addNewFunc.setType("Test");
382 addNewFunc.setAction("Test");
383 addNewFunc.setName("Test");
384 CentralV2RoleFunction roleFunction = mockCentralRoleFunction();
385 roleFunction.setCode("Test|Test|Test");
386 Mockito.when(externalAccessRolesService.getRoleFunction("Test|Test|Test", "test")).thenReturn(roleFunction);
387 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(Matchers.anyObject(), Matchers.anyObject()))
389 Mockito.when(EcompPortalUtils.getFunctionCode(roleFunction.getCode())).thenReturn("Test");
390 Mockito.when(EcompPortalUtils.getFunctionType(roleFunction.getCode())).thenReturn("Test");
391 Mockito.when(EcompPortalUtils.getFunctionAction(roleFunction.getCode())).thenReturn("Test");
392 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
393 List<EPUser> userList = new ArrayList<>();
395 List<EPApp> appList = new ArrayList<>();
396 appList.add(CentralApp());
397 Mockito.when(externalAccessRolesService.getUser("guestT")).thenReturn(userList);
398 StringWriter sw = new StringWriter();
399 PrintWriter writer = new PrintWriter(sw);
400 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
401 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
402 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(Matchers.anyObject())).thenReturn(response);
403 Mockito.when(externalAccessRolesService.getApp(Matchers.anyString())).thenReturn(appList);
404 PortalRestResponse<String> actual = roleManageController.saveRoleFunction(mockedRequest, mockedResponse,
405 addNewFunc, (long) 1);
406 PortalRestResponse<String> expected = new PortalRestResponse<String>(PortalRestStatusEnum.ERROR,
407 "Data is not valid", "ERROR");
408 assertEquals(expected, actual);
412 public void saveRoleFunctionExceptionTest() throws Exception {
413 Mockito.when(appService.getApp((long) 1)).thenReturn(CentralApp());
414 Mockito.doNothing().when(roleFunctionListController).saveRoleFunction(mockedRequest, mockedResponse, "test");
415 CentralV2RoleFunction addNewFunc = new CentralV2RoleFunction();
416 addNewFunc.setCode("Test");
417 addNewFunc.setName("Test");
418 Mockito.when(externalAccessRolesService.getRoleFunction("Test", "test")).thenReturn(null);
419 roleManageController.saveRoleFunction(mockedRequest, mockedResponse, addNewFunc, (long) 1);
423 public void saveRoleFunctionIfAppNotCentralizedTest() throws Exception {
424 CentralV2RoleFunction addNewFunc = new CentralV2RoleFunction();
425 addNewFunc.setCode("Test");
426 addNewFunc.setName("Test");
427 Mockito.when(appService.getApp((long) 1)).thenReturn(NonCentralApp());
428 roleManageController.saveRoleFunction(mockedRequest, mockedResponse, addNewFunc, (long) 1);
432 public void removeRoleFunctionTest() throws Exception {
433 PowerMockito.mockStatic(EPUserUtils.class);
434 PowerMockito.mockStatic(EcompPortalUtils.class);
435 EPUser user = mockUser.mockEPUser();
436 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
437 Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true);
438 Mockito.when(adminRolesService.isAccountAdminOfApplication(user, CentralApp())).thenReturn(true);
439 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
440 Mockito.when(appService.getApp((long) 1)).thenReturn(CentralApp());
441 String roleFun = "{\"name\":\"Test\",\"type\":\"Test\",\"action\":\"Test\", \"code\":\"Test\"}";
442 CentralV2RoleFunction roleFunction = mockCentralRoleFunction();
443 Mockito.when(externalAccessRolesService.getRoleFunction("Test|Test|Test", "test")).thenReturn(roleFunction);
444 StringWriter sw = new StringWriter();
445 PrintWriter writer = new PrintWriter(sw);
446 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
447 Mockito.when(externalAccessRolesService.deleteCentralRoleFunction(Matchers.anyString(), Matchers.anyObject()))
449 List<EPApp> appList = new ArrayList<>();
450 appList.add(CentralApp());
451 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
452 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(Matchers.anyObject())).thenReturn(response);
453 Mockito.when(externalAccessRolesService.getApp(Matchers.anyString())).thenReturn(appList);
454 PortalRestResponse<String> actual = roleManageController.removeRoleFunction(mockedRequest, mockedResponse,
456 PortalRestResponse<String> expected = new PortalRestResponse<String>(PortalRestStatusEnum.OK,
457 "Deleted Successfully!", "Success");
458 assertEquals(expected, actual);
462 public void removeRoleFunctionXSSTest() throws Exception {
463 PowerMockito.mockStatic(EPUserUtils.class);
464 PowerMockito.mockStatic(EcompPortalUtils.class);
465 EPUser user = mockUser.mockEPUser();
466 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
467 Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true);
468 Mockito.when(adminRolesService.isAccountAdminOfApplication(user, CentralApp())).thenReturn(true);
469 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
470 Mockito.when(appService.getApp((long) 1)).thenReturn(CentralApp());
471 String roleFun = "<script>alert(/XSS”)</script>";
472 CentralV2RoleFunction roleFunction = mockCentralRoleFunction();
473 Mockito.when(externalAccessRolesService.getRoleFunction("Test|Test|Test", "test")).thenReturn(roleFunction);
474 StringWriter sw = new StringWriter();
475 PrintWriter writer = new PrintWriter(sw);
476 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
477 Mockito.when(externalAccessRolesService.deleteCentralRoleFunction(Matchers.anyString(), Matchers.anyObject()))
479 List<EPApp> appList = new ArrayList<>();
480 appList.add(CentralApp());
481 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
482 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(Matchers.anyObject())).thenReturn(response);
483 Mockito.when(externalAccessRolesService.getApp(Matchers.anyString())).thenReturn(appList);
484 PortalRestResponse<String> actual = roleManageController.removeRoleFunction(mockedRequest, mockedResponse,
486 PortalRestResponse<String> expected = new PortalRestResponse<String>(PortalRestStatusEnum.ERROR,
487 "Data is not valid", "ERROR");
488 assertEquals(expected, actual);
492 public void removeRoleFunctionExceptionTest() throws Exception {
493 EPUser user = mockUser.mockEPUser();
494 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
495 Mockito.when(appService.getApp((long) 1)).thenReturn(CentralApp());
496 String roleFun = "{\"name\":\"Test\",\"code\":\"Test\"}";
497 CentralV2RoleFunction roleFunction = mockCentralRoleFunction();
498 Mockito.when(externalAccessRolesService.getRoleFunction("Test", "test")).thenReturn(roleFunction);
499 StringWriter sw = new StringWriter();
500 PrintWriter writer = new PrintWriter(sw);
501 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
502 Mockito.when(externalAccessRolesService.deleteCentralRoleFunction(Matchers.anyString(), Matchers.anyObject()))
504 List<EPApp> appList = new ArrayList<>();
505 appList.add(CentralApp());
506 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
507 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(Matchers.anyObject())).thenReturn(response);
508 Mockito.when(externalAccessRolesService.getApp(Matchers.anyString())).thenReturn(appList);
509 roleManageController.removeRoleFunction(mockedRequest, mockedResponse, roleFun, (long) 1);
513 public void removeRoleFunctionIfAppNotCentralizedTest() throws Exception {
514 EPApp app = mockApp();
515 app.setCentralAuth(false);
516 Mockito.when(appService.getApp((long) 1)).thenReturn(app);
517 String roleFun = "{\"name\":\"Test\",\"code\":\"Test\"}";
518 roleManageController.removeRoleFunction(mockedRequest, mockedResponse, roleFun, (long) 1);
522 public void syncRolesTest() throws Exception {
523 PowerMockito.mockStatic(EPUserUtils.class);
524 PowerMockito.mockStatic(EcompPortalUtils.class);
525 Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true);
526 EPUser user = mockUser.mockEPUser();
527 EPApp app = mockApp();
529 Mockito.when(appService.getApp(1l)).thenReturn(app);
530 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
531 Mockito.when(adminRolesService.isSuperAdmin(Matchers.anyObject())).thenReturn(true);
532 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
533 List<EPApp> appList = new ArrayList<>();
534 appList.add(CentralApp());
535 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
536 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(Matchers.anyObject())).thenReturn(response);
537 Mockito.when(externalAccessRolesService.getApp(Matchers.anyString())).thenReturn(appList);
538 PortalRestResponse<String> actual = roleManageController.syncRoles(mockedRequest, mockedResponse, 1l);
539 PortalRestResponse<String> portalRestResponse = new PortalRestResponse<>();
540 portalRestResponse.setMessage("Sync roles completed successfully!");
541 portalRestResponse.setResponse("Success");
542 portalRestResponse.setStatus(PortalRestStatusEnum.OK);
543 assertEquals(portalRestResponse, actual);
547 public void syncRolesException() throws Exception {
548 EPUser user = mockUser.mockEPUser();
549 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
550 Mockito.when(adminRolesService.isAccountAdminOfApplication(user, null)).thenReturn(true);
551 Mockito.when(appService.getAppDetailByAppName("test")).thenThrow(nullPointerException);
552 PortalRestResponse<String> actual = roleManageController.syncRoles(mockedRequest, mockedResponse, 1l);
553 PortalRestResponse<String> portalRestResponse = new PortalRestResponse<>();
554 portalRestResponse.setMessage(null);
555 portalRestResponse.setResponse("Failed");
556 portalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
557 assertEquals(portalRestResponse, actual);
561 public void syncRolesUserNullException() throws Exception {
562 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(null);
563 Mockito.when(appService.getAppDetailByAppName("test")).thenThrow(nullPointerException);
564 PortalRestResponse<String> actual = roleManageController.syncRoles(mockedRequest, mockedResponse, 1l);
565 PortalRestResponse<String> portalRestResponse = new PortalRestResponse<>();
566 portalRestResponse.setMessage("Unauthorized User");
567 portalRestResponse.setResponse("Failure");
568 portalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
569 assertEquals(portalRestResponse, actual);
573 public void syncRolesFunctionsTest() throws Exception {
574 PowerMockito.mockStatic(EPUserUtils.class);
575 PowerMockito.mockStatic(EcompPortalUtils.class);
576 Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true);
577 EPApp app = mockApp();
579 EPUser user = mockUser.mockEPUser();
580 Mockito.when(appService.getApp(1l)).thenReturn(app);
581 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
582 Mockito.when(adminRolesService.isSuperAdmin(Matchers.anyObject())).thenReturn(true);
583 Mockito.doNothing().when(externalAccessRolesService).syncRoleFunctionFromExternalAccessSystem(app);
584 List<EPApp> appList = new ArrayList<>();
585 appList.add(CentralApp());
586 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
587 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(Matchers.anyObject())).thenReturn(response);
588 Mockito.when(externalAccessRolesService.getApp(Matchers.anyString())).thenReturn(appList);
589 PortalRestResponse<String> actual = roleManageController.syncFunctions(mockedRequest, mockedResponse, 1l);
590 PortalRestResponse<String> portalRestResponse = new PortalRestResponse<>();
591 portalRestResponse.setMessage("Sync Functions completed successfully!");
592 portalRestResponse.setResponse("Success");
593 portalRestResponse.setStatus(PortalRestStatusEnum.OK);
594 assertEquals(portalRestResponse, actual);
598 public void syncRolesFunctionsException() throws Exception {
599 EPUser user = mockUser.mockEPUser();
600 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
601 Mockito.when(adminRolesService.isAccountAdminOfApplication(user, null)).thenReturn(true);
602 Mockito.when(appService.getAppDetailByAppName("test")).thenThrow(nullPointerException);
603 PortalRestResponse<String> actual = roleManageController.syncFunctions(mockedRequest, mockedResponse, 1l);
604 PortalRestResponse<String> portalRestResponse = new PortalRestResponse<>();
605 portalRestResponse.setMessage(null);
606 portalRestResponse.setResponse("Failed");
607 portalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
608 assertEquals(portalRestResponse, actual);
612 public void syncRolesFunctionsUserNullException() throws Exception {
613 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(null);
614 Mockito.when(appService.getAppDetailByAppName("test")).thenThrow(nullPointerException);
615 PortalRestResponse<String> actual = roleManageController.syncFunctions(mockedRequest, mockedResponse, 1l);
616 PortalRestResponse<String> portalRestResponse = new PortalRestResponse<>();
617 portalRestResponse.setMessage("Unauthorized User");
618 portalRestResponse.setResponse("Failure");
619 portalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
620 assertEquals(portalRestResponse, actual);
624 public void addChildRoleTest() throws Exception {
625 ModelAndView modelandView = new ModelAndView("login.htm");
626 Mockito.when(roleController.addChildRole(mockedRequest, mockedResponse)).thenReturn(modelandView);
627 ModelAndView expectedModelandView = roleManageController.addChildRole(mockedRequest, mockedResponse);
628 assertEquals(expectedModelandView, modelandView);
632 public void removeRoleTest() throws Exception {
633 PowerMockito.mockStatic(EPUserUtils.class);
634 PowerMockito.mockStatic(EcompPortalUtils.class);
635 Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true);
636 List<EPUser> epuserList = new ArrayList<>();
637 List<EPApp> appList = new ArrayList<>();
638 appList.add(CentralApp());
639 EPUser user = mockUser.mockEPUser();
640 epuserList.add(user);
641 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
642 Mockito.when(appService.getApp((long) 1)).thenReturn(CentralApp());
643 Mockito.when(adminRolesService.isSuperAdmin(Matchers.anyObject())).thenReturn(true);
644 StringWriter sw = new StringWriter();
645 PrintWriter writer = new PrintWriter(sw);
646 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
647 ExternalRequestFieldsValidator res = new ExternalRequestFieldsValidator(true, "success");
648 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(), Matchers.anyString(),
649 Matchers.anyString())).thenReturn(res);
650 Mockito.when(externalAccessRolesService.getUser(Matchers.anyString())).thenReturn(epuserList);
651 Mockito.when(externalAccessRolesService.getApp(Matchers.anyString())).thenReturn(appList);
652 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
653 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(Matchers.anyObject())).thenReturn(response);
654 Map<String, Object> expedtedResponse = new HashMap<String, Object>();
655 expedtedResponse.put("restCallStatus", " Unauthorized user");
656 expedtedResponse.put("availableRoles", new ArrayList<>());
657 Map<String, Object> actualResponse = roleManageController.removeRole(mockedRequest, mockedResponse, (long) 1,
659 assertEquals(actualResponse.size(), expedtedResponse.size());
663 @Test(expected = Exception.class)
664 public void removeRoleExceptionTest() throws Exception {
665 EPUser user = mockUser.mockEPUser();
666 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
667 Mockito.when(appService.getApp((long) 1)).thenThrow(nullPointerException);
668 StringWriter sw = new StringWriter();
669 PrintWriter writer = new PrintWriter(sw);
670 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
671 roleManageController.removeRole(mockedRequest, mockedResponse, (long) 1, (long) 1);
674 @SuppressWarnings("unchecked")
676 public void saveRoleNewTest() throws Exception {
677 PowerMockito.mockStatic(EPUserUtils.class);
678 PowerMockito.mockStatic(EcompPortalUtils.class);
679 Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true);
680 List<EPUser> epuserList = new ArrayList<>();
681 List<EPApp> appList = new ArrayList<>();
682 appList.add(CentralApp());
683 EPUser user = mockUser.mockEPUser();
684 epuserList.add(user);
685 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
686 Mockito.when(appService.getApp((long) 1)).thenReturn(CentralApp());
687 Mockito.when(adminRolesService.isSuperAdmin(Matchers.anyObject())).thenReturn(true);
688 Mockito.when(externalAccessRolesService.getApp(Matchers.anyString())).thenReturn(appList);
689 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
690 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(Matchers.anyObject())).thenReturn(response);
691 JSONObject roleJson = new JSONObject();
692 roleJson.put("name", "test");
693 JSONObject roleJson2 = new JSONObject();
694 List<JSONObject> childRolesJson = new ArrayList<>();
695 List<JSONObject> roleFunctions = new ArrayList<>();
696 roleJson2.put("role", roleJson);
697 roleJson2.put("childRoles", childRolesJson);
698 roleJson2.put("roleFunctions", roleFunctions);
699 ObjectMapper mapper = new ObjectMapper();
700 JsonNode actualObj = mapper.readTree(roleJson2.toString());
701 dsi = new DelegatingServletInputStream(
702 new ByteArrayInputStream(actualObj.toString().getBytes(StandardCharsets.UTF_8)));
703 Mockito.when(mockedRequest.getInputStream()).thenReturn(dsi);
704 Mockito.when(mockedRequest.getReader()).thenReturn(new BufferedReader(new StringReader(actualObj.toString())));
705 Mockito.when(mockedRequest.getContentType()).thenReturn("application/json");
706 Mockito.when(mockedRequest.getCharacterEncoding()).thenReturn("UTF-8");
707 Mockito.when(externalAccessRolesService.ConvertCentralRoleToRole(Matchers.anyString())).thenReturn(new Role());
708 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(true, "");
709 Mockito.when(externalAccessRolesService.saveRoleForApplication(Matchers.any(), Matchers.any()))
710 .thenReturn(externalRequestFieldsValidator);
711 Map<String, Object> actual = roleManageController.saveRole(mockedRequest, mockedResponse, CentralApp().getId());
712 final Map<String, Object> expected = new HashMap<>();
714 new CentralV2Role.CentralV2RoleBuilder().setId(null).setName("test").createCentralV2Role());
715 expected.put("status", "Success");
716 assertEquals(expected, actual);
719 @SuppressWarnings("unchecked")
721 public void saveRoleUpdateTest() throws Exception {
722 PowerMockito.mockStatic(EPUserUtils.class);
723 PowerMockito.mockStatic(EcompPortalUtils.class);
724 Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true);
725 List<EPUser> epuserList = new ArrayList<>();
726 List<EPApp> appList = new ArrayList<>();
727 appList.add(CentralApp());
728 EPUser user = mockUser.mockEPUser();
729 epuserList.add(user);
730 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
731 Mockito.when(appService.getApp((long) 1)).thenReturn(CentralApp());
732 Mockito.when(adminRolesService.isSuperAdmin(Matchers.anyObject())).thenReturn(true);
733 Mockito.when(externalAccessRolesService.getApp(Matchers.anyString())).thenReturn(appList);
734 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
735 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(Matchers.anyObject())).thenReturn(response);
736 JSONObject roleJson = new JSONObject();
737 roleJson.put("id", 1);
738 roleJson.put("name", "test");
739 roleJson.put("active", true);
740 JSONObject roleJson2 = new JSONObject();
741 List<JSONObject> childRolesJson = new ArrayList<>();
742 List<JSONObject> roleFunctions = new ArrayList<>();
743 JSONObject roleFunction = new JSONObject();
744 roleFunction.put("code", "test");
745 roleFunction.put("name", "test");
746 roleFunction.put("type", "test");
747 roleFunction.put("action", "test");
748 roleFunctions.add(roleFunction);
749 roleJson.put("roleFunctions", roleFunctions);
750 roleJson2.put("role", roleJson);
751 roleJson2.put("childRoles", childRolesJson);
752 roleJson2.put("roleFunctions", roleFunctions);
753 ObjectMapper mapper = new ObjectMapper();
754 JsonNode actualObj = mapper.readTree(roleJson2.toString());
755 dsi = new DelegatingServletInputStream(
756 new ByteArrayInputStream(actualObj.toString().getBytes(StandardCharsets.UTF_8)));
757 Mockito.when(mockedRequest.getInputStream()).thenReturn(dsi);
758 Mockito.when(mockedRequest.getReader()).thenReturn(new BufferedReader(new StringReader(actualObj.toString())));
759 Mockito.when(mockedRequest.getContentType()).thenReturn("application/json");
760 Mockito.when(mockedRequest.getCharacterEncoding()).thenReturn("UTF-8");
761 Mockito.when(externalAccessRolesService.ConvertCentralRoleToRole(Matchers.anyString())).thenReturn(new Role());
762 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(true, "");
763 Mockito.when(externalAccessRolesService.saveRoleForApplication(Matchers.any(), Matchers.any()))
764 .thenReturn(externalRequestFieldsValidator);
765 CentralV2Role cenV2Role =
766 new CentralV2Role.CentralV2RoleBuilder().setId(1l).setName("test1").createCentralV2Role();
767 cenV2Role.setActive(true);
768 Mockito.when(externalAccessRolesService.getRoleInfo(Matchers.anyLong(), Matchers.any())).thenReturn(cenV2Role);
769 Map<String, Object> actual = roleManageController.saveRole(mockedRequest, mockedResponse, CentralApp().getId());
770 final Map<String, Object> expected = new HashMap<>();
771 expected.put("status", "Success");
772 assertEquals(expected.get("status"), actual.get("status"));
775 @SuppressWarnings("unchecked")
777 public void saveRoleInvalidRoleExceptionTest() throws Exception {
778 PowerMockito.mockStatic(EPUserUtils.class);
779 PowerMockito.mockStatic(EcompPortalUtils.class);
780 Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true);
781 List<EPUser> epuserList = new ArrayList<>();
782 List<EPApp> appList = new ArrayList<>();
783 appList.add(CentralApp());
784 EPUser user = mockUser.mockEPUser();
785 epuserList.add(user);
786 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
787 Mockito.when(appService.getApp((long) 1)).thenReturn(CentralApp());
788 Mockito.when(adminRolesService.isSuperAdmin(Matchers.anyObject())).thenReturn(true);
789 Mockito.when(externalAccessRolesService.getApp(Matchers.anyString())).thenReturn(appList);
790 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
791 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(Matchers.anyObject())).thenReturn(response);
792 JSONObject roleJson = new JSONObject();
793 roleJson.put("id", 1);
794 roleJson.put("name", "test%%");
795 roleJson.put("active", true);
796 JSONObject roleJson2 = new JSONObject();
797 List<JSONObject> childRolesJson = new ArrayList<>();
798 List<JSONObject> roleFunctions = new ArrayList<>();
799 JSONObject roleFunction = new JSONObject();
800 roleFunction.put("code", "test");
801 roleFunction.put("name", "test");
802 roleFunction.put("type", "test");
803 roleFunction.put("action", "test");
804 roleFunctions.add(roleFunction);
805 roleJson.put("roleFunctions", roleFunctions);
806 roleJson2.put("role", roleJson);
807 roleJson2.put("childRoles", childRolesJson);
808 roleJson2.put("roleFunctions", roleFunctions);
809 ObjectMapper mapper = new ObjectMapper();
810 JsonNode actualObj = mapper.readTree(roleJson2.toString());
811 dsi = new DelegatingServletInputStream(
812 new ByteArrayInputStream(actualObj.toString().getBytes(StandardCharsets.UTF_8)));
813 Mockito.when(mockedRequest.getInputStream()).thenReturn(dsi);
814 Mockito.when(mockedRequest.getReader()).thenReturn(new BufferedReader(new StringReader(actualObj.toString())));
815 Mockito.when(mockedRequest.getContentType()).thenReturn("application/json");
816 Mockito.when(mockedRequest.getCharacterEncoding()).thenReturn("UTF-8");
817 Map<String, Object> actual = roleManageController.saveRole(mockedRequest, mockedResponse, CentralApp().getId());
818 final Map<String, Object> expected = new HashMap<>();
819 expected.put("error", "Invalid role name found for 'test%%'. Any one of the following characters '%,(),=,:,comma, and double quotes' are not allowed");
820 assertEquals(expected.get("error"), actual.get("error"));
824 public void saveRoleUnauthorizedUserExceptionTest() throws Exception {
825 PowerMockito.mockStatic(EPUserUtils.class);
826 PowerMockito.mockStatic(EcompPortalUtils.class);
827 Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true);
828 List<EPUser> epuserList = new ArrayList<>();
829 List<EPApp> appList = new ArrayList<>();
830 appList.add(CentralApp());
831 EPUser user = mockUser.mockEPUser();
832 epuserList.add(user);
833 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
834 Mockito.when(appService.getApp((long) 1)).thenReturn(CentralApp());
835 Mockito.when(adminRolesService.isSuperAdmin(Matchers.anyObject())).thenReturn(false);
836 Mockito.when(externalAccessRolesService.getApp(Matchers.anyString())).thenReturn(appList);
837 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
838 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(Matchers.anyObject())).thenReturn(response);
839 Map<String, Object> actual = roleManageController.saveRole(mockedRequest, mockedResponse, CentralApp().getId());
840 final Map<String, Object> expected = new HashMap<>();
841 expected.put("error", " Unauthorized user");
842 assertEquals(expected.get("error"), actual.get("error"));
846 public void toggleRoleTest() throws Exception {
847 PowerMockito.mockStatic(EPUserUtils.class);
848 PowerMockito.mockStatic(EcompPortalUtils.class);
849 Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true);
850 List<EPUser> epuserList = new ArrayList<>();
851 List<EPApp> appList = new ArrayList<>();
852 appList.add(CentralApp());
853 EPUser user = mockUser.mockEPUser();
854 epuserList.add(user);
855 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
856 Mockito.when(appService.getApp((long) 1)).thenReturn(CentralApp());
857 Mockito.when(adminRolesService.isSuperAdmin(Matchers.anyObject())).thenReturn(true);
858 Mockito.when(externalAccessRolesService.getApp(Matchers.anyString())).thenReturn(appList);
859 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
860 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(Matchers.anyObject())).thenReturn(response);
861 CentralV2Role role = new CentralV2Role.CentralV2RoleBuilder().setId(1l).setName("test").createCentralV2Role();
862 role.setActive(true);
863 Role currentRole = new Role();
864 currentRole.setName("test");
865 Mockito.when(externalAccessRolesService.getRoleInfo(Matchers.anyLong(), Matchers.any())).thenReturn(role);
866 Mockito.when(externalAccessRolesService.ConvertCentralRoleToRole(Matchers.anyString())).thenReturn(currentRole);
867 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(true, "");
868 Mockito.when(externalAccessRolesService.saveRoleForApplication(Matchers.any(),Matchers.any())).thenReturn(externalRequestFieldsValidator);
869 Map<String, Object> actual = roleManageController.toggleRole(mockedRequest, mockedResponse, CentralApp().getId(), 1l);
870 final Map<String, Object> expected = new HashMap<>();
871 expected.put("restcallStatus", "Success");
872 assertEquals(expected.get("restcallStatus"), actual.get("restcallStatus"));
876 public void toggleRoleUnauthorizedUserExceptionTest() throws Exception {
877 PowerMockito.mockStatic(EPUserUtils.class);
878 PowerMockito.mockStatic(EcompPortalUtils.class);
879 Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true);
880 List<EPUser> epuserList = new ArrayList<>();
881 List<EPApp> appList = new ArrayList<>();
882 appList.add(CentralApp());
883 EPUser user = mockUser.mockEPUser();
884 epuserList.add(user);
885 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
886 Mockito.when(appService.getApp((long) 1)).thenReturn(CentralApp());
887 Mockito.when(adminRolesService.isSuperAdmin(Matchers.anyObject())).thenReturn(false);
888 Mockito.when(externalAccessRolesService.getApp(Matchers.anyString())).thenReturn(appList);
889 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
890 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(Matchers.anyObject())).thenReturn(response);
891 Map<String, Object> actual = roleManageController.toggleRole(mockedRequest, mockedResponse, CentralApp().getId(), 1l);
892 final Map<String, Object> expected = new HashMap<>();
893 expected.put("restcallStatus", " Unauthorized user");
894 assertEquals(expected.get("restcallStatus"), actual.get("restcallStatus"));
897 @Test(expected = NullPointerException.class)
898 public void toggleRoleExceptionTest() throws Exception {
899 PowerMockito.mockStatic(EPUserUtils.class);
900 PowerMockito.mockStatic(EcompPortalUtils.class);
901 Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true);
902 List<EPUser> epuserList = new ArrayList<>();
903 List<EPApp> appList = new ArrayList<>();
904 appList.add(CentralApp());
905 EPUser user = mockUser.mockEPUser();
906 epuserList.add(user);
907 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
908 Mockito.doThrow(new NullPointerException()).when(appService).getApp((long) 1);
909 roleManageController.toggleRole(mockedRequest, mockedResponse, CentralApp().getId(), 1l);
913 public void toggleRoleFailedTest() throws Exception {
914 PowerMockito.mockStatic(EPUserUtils.class);
915 PowerMockito.mockStatic(EcompPortalUtils.class);
916 Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true);
917 List<EPUser> epuserList = new ArrayList<>();
918 List<EPApp> appList = new ArrayList<>();
919 appList.add(CentralApp());
920 EPUser user = mockUser.mockEPUser();
921 epuserList.add(user);
922 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
923 Mockito.when(appService.getApp((long) 1)).thenReturn(CentralApp());
924 Mockito.when(adminRolesService.isSuperAdmin(Matchers.anyObject())).thenReturn(true);
925 Mockito.when(externalAccessRolesService.getApp(Matchers.anyString())).thenReturn(appList);
926 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
927 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(Matchers.anyObject())).thenReturn(response);
928 CentralV2Role role = new CentralV2Role.CentralV2RoleBuilder().setId(1l).setName("test").createCentralV2Role();
929 role.setActive(true);
930 Role currentRole = new Role();
931 currentRole.setName("test");
932 Mockito.when(externalAccessRolesService.getRoleInfo(Matchers.anyLong(), Matchers.any())).thenReturn(role);
933 Mockito.when(externalAccessRolesService.ConvertCentralRoleToRole(Matchers.anyString())).thenReturn(currentRole);
934 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false, "");
935 Mockito.when(externalAccessRolesService.saveRoleForApplication(Matchers.any(),Matchers.any())).thenReturn(externalRequestFieldsValidator);
936 Map<String, Object> actual = roleManageController.toggleRole(mockedRequest, mockedResponse, CentralApp().getId(), 1l);
937 final Map<String, Object> expected = new HashMap<>();
938 expected.put("restcallStatus", "Toggle Role Failed");
939 assertEquals(expected.get("restcallStatus"), actual.get("restcallStatus"));
943 public void getAvailableChildRolesTest() throws Exception {
944 List<CentralV2Role> centralV2Roles = new ArrayList<>();
945 CentralV2Role centralV2Role = new CentralV2Role();
946 centralV2Role.setName("test");
947 centralV2Role.setId(1l);
948 CentralV2Role centralV2Role2 = new CentralV2Role();
949 centralV2Role2.setName("test");
950 centralV2Role2.setId(1l);
951 centralV2Roles.add(centralV2Role);
952 centralV2Roles.add(centralV2Role2);
953 SortedSet<CentralV2RoleFunction> roleFuns = new TreeSet<>();
954 CentralV2RoleFunction centralV2RoleFunction = new CentralV2RoleFunction("test", "test");
955 roleFuns.add(centralV2RoleFunction);
956 CentralV2Role currentRole = new CentralV2Role();
957 currentRole.setName("test");
958 currentRole.setId(1l);
959 currentRole.setRoleFunctions(roleFuns);
960 Mockito.when(externalAccessRolesService.getRolesForApp(CentralApp().getUebKey())).thenReturn(centralV2Roles);
961 Mockito.when(externalAccessRolesService.getRoleInfo(1l, CentralApp().getUebKey())).thenReturn(currentRole);
962 List<CentralV2Role> actual = roleManageController.getAvailableChildRoles(CentralApp().getUebKey(), 1l);
963 assertEquals(new ArrayList<>().size(), actual.size());
967 public void getCentralizedAppRolesTest() throws IOException {
968 PowerMockito.mockStatic(EPUserUtils.class);
969 EPUser user = mockUser.mockEPUser();
970 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
971 List<CentralizedApp> cenApps = new ArrayList<>();
972 CentralizedApp centralizedApp = new CentralizedApp();
973 centralizedApp.setAppId(1);
974 centralizedApp.setAppName("Test");
975 cenApps.add(centralizedApp);
976 Mockito.when(adminRolesService.isSuperAdmin(Matchers.anyObject())).thenReturn(true);
977 Mockito.when(externalAccessRolesService.getCentralizedAppsOfUser(Matchers.anyString())).thenReturn(cenApps);
978 List<CentralizedApp> actual = roleManageController.getCentralizedAppRoles(mockedRequest, mockedResponse, user.getOrgUserId());
979 assertEquals(cenApps.size(), actual.size());
983 public void getCentralizedAppRolesXSSTest() throws IOException {
984 String id = ("<ScRipT>alert(\"XSS\");</ScRipT>");
985 List<CentralizedApp> actual = roleManageController.getCentralizedAppRoles(mockedRequest, mockedResponse, id);
990 public void getCentralizedAppRolesExceptionTest() throws IOException {
991 PowerMockito.mockStatic(EPUserUtils.class);
992 EPUser user = mockUser.mockEPUser();
993 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
994 List<CentralizedApp> cenApps = new ArrayList<>();
995 CentralizedApp centralizedApp = new CentralizedApp();
996 centralizedApp.setAppId(1);
997 centralizedApp.setAppName("Test");
998 cenApps.add(centralizedApp);
999 Mockito.when(adminRolesService.isAccountAdmin(Matchers.anyObject())).thenReturn(false);
1000 List<CentralizedApp> actual = roleManageController.getCentralizedAppRoles(mockedRequest, mockedResponse, user.getOrgUserId());
1005 public void bulkUploadRoleFuncUserNullTest() {
1006 UploadRoleFunctionExtSystem data = Mockito.mock(UploadRoleFunctionExtSystem.class);
1007 Mockito.when(appService.getApp(127L)).thenReturn(null);
1008 PortalRestResponse<String> response = roleManageController.bulkUploadRoleFunc(mockedRequest, mockedResponse, data, 127L);
1009 assertEquals(PortalRestStatusEnum.ERROR, response.getStatus());
1010 assertEquals("Unauthorized User", response.getMessage());
1011 assertEquals("Failure", response.getResponse());
1014 public CentralV2RoleFunction mockCentralRoleFunction() {
1015 CentralV2RoleFunction roleFunction = new CentralV2RoleFunction();
1016 roleFunction.setCode("Test");
1017 roleFunction.setName("Test");
1018 roleFunction.setAppId((long) 1);
1019 return roleFunction;
1022 public EPApp CentralApp() {
1023 EPApp app = mockApp();
1024 app.setCentralAuth(true);
1025 app.setNameSpace("com.test");
1029 public EPApp NonCentralApp() {
1030 EPApp app = mockApp();
1031 app.setCentralAuth(false);