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.domain.EpAppType;
67 import org.onap.portalapp.portal.ecomp.model.PortalRestResponse;
68 import org.onap.portalapp.portal.ecomp.model.PortalRestStatusEnum;
69 import org.onap.portalapp.portal.framework.MockitoTestSuite;
70 import org.onap.portalapp.portal.service.ExternalAccessRolesService;
71 import org.onap.portalapp.portal.service.ExternalAccessRolesServiceImpl;
72 import org.onap.portalapp.portal.transport.*;
73 import org.onap.portalapp.portal.utils.EPCommonSystemProperties;
74 import org.onap.portalapp.portal.utils.EcompPortalUtils;
75 import org.onap.portalapp.portal.utils.PortalConstants;
76 import org.onap.portalsdk.core.domain.AuditLog;
77 import org.onap.portalsdk.core.domain.Role;
78 import org.onap.portalsdk.core.domain.User;
79 import org.onap.portalsdk.core.restful.domain.EcompRole;
80 import org.onap.portalsdk.core.restful.domain.EcompUser;
81 import org.onap.portalsdk.core.service.AuditService;
82 import org.onap.portalsdk.core.service.UserService;
83 import org.onap.portalsdk.core.service.UserServiceCentalizedImpl;
84 import org.onap.portalsdk.core.util.SystemProperties;
85 import org.powermock.api.mockito.PowerMockito;
86 import org.powermock.core.classloader.annotations.PrepareForTest;
87 import org.powermock.modules.junit4.PowerMockRunner;
88 import org.springframework.http.HttpStatus;
89 import org.springframework.http.ResponseEntity;
90 import org.springframework.web.client.HttpClientErrorException;
92 import com.fasterxml.jackson.core.JsonProcessingException;
93 import com.fasterxml.jackson.databind.DeserializationFeature;
94 import com.fasterxml.jackson.databind.ObjectMapper;
96 @RunWith(PowerMockRunner.class)
97 @PrepareForTest({ EcompPortalUtils.class, PortalConstants.class, SystemProperties.class,
98 EPCommonSystemProperties.class })
99 public class ExternalAccessRolesControllerTest {
101 ExternalAccessRolesService externalAccessRolesService = new ExternalAccessRolesServiceImpl();
103 ExternalAccessRolesController externalAccessRolesController;
105 UserService userservice = new UserServiceCentalizedImpl();
107 AuditService auditService;
110 public void setup() {
111 MockitoAnnotations.initMocks(this);
115 AuditLog auditLog = new AuditLog();
116 MockitoTestSuite mockitoTestSuite = new MockitoTestSuite();
117 HttpServletRequest mockedRequest = mockitoTestSuite.getMockedRequest();
118 HttpServletResponse mockedResponse = mockitoTestSuite.getMockedResponse();
119 NullPointerException nullPointerException = new NullPointerException();
120 HttpClientErrorException httpClientErrorException = new HttpClientErrorException(HttpStatus.BAD_REQUEST, "Failed");
121 MockEPUser mockUser = new MockEPUser();
122 String loginId = "guestT";
123 String uebKey = "testUebKey";
125 public EPApp mockApp() {
126 EPApp app = new EPApp();
128 app.setImageUrl("test");
129 app.setAppDescription("test");
130 app.setAppNotes("test");
131 app.setLandingPage("test");
133 app.setAppRestEndpoint("test");
134 app.setAlternateLandingPage("test");
136 app.setMlAppName("test");
137 app.setMlAppAdminId("test");
138 app.setAppBasicAuthUsername("test");
139 app.setAppBasicAuthPassword("test");
141 app.setEnabled(false);
142 app.setUebKey("test");
143 app.setUebSecret("test");
144 app.setUebTopicName("test");
145 app.setAppType(EpAppType.GUI);
150 public void getUserTest() throws Exception {
151 CentralUser expectedCentralUser =
152 new CentralUser.CentralUserBuilder().setId(null).setCreated(null).setModified(null).setCreatedId(null)
153 .setModifiedId(null).setRowNum(null).setOrgId(null).setManagerId(null).setFirstName(loginId)
154 .setMiddleInitial(loginId).setLastName(loginId).setPhone(loginId).setFax(loginId)
155 .setCellular(loginId).setEmail(loginId).setAddressId(null).setAlertMethodCd(loginId)
156 .setHrid(loginId).setOrgUserId(loginId).setOrgCode(loginId).setAddress1(loginId)
157 .setAddress2(loginId).setCity(loginId).setState(loginId).setZipCode(loginId).setCountry(loginId)
158 .setOrgManagerUserId(loginId).setLocationClli(loginId).setBusinessCountryCode(loginId)
159 .setBusinessCountryName(loginId).setBusinessUnit(loginId).setBusinessUnitName(loginId)
160 .setDepartment(loginId).setDepartmentName(loginId).setCompanyCode(loginId).setCompany(loginId)
161 .setZipCodeSuffix(loginId).setJobTitle(loginId).setCommandChain(loginId).setSiloStatus(loginId)
162 .setCostCenter(loginId).setFinancialLocCode(loginId).setLoginId(loginId).setLoginPwd(loginId)
163 .setLastLoginDate(null).setActive(false).setInternal(false).setSelectedProfileId(null)
164 .setTimeZoneId(null).setOnline(false).setChatId(loginId).setUserApps(null).createCentralUser();
165 String loginId = "test";
166 StringWriter sw = new StringWriter();
167 PrintWriter writer = new PrintWriter(sw);
168 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
169 EPApp app = mockApp();
170 app.setRolesInAAF(true);
171 List<EPApp> appList = new ArrayList<>();
173 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
174 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
175 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
176 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
177 Mockito.when(externalAccessRolesService.getUserRoles(loginId, mockedRequest.getHeader("uebkey")))
178 .thenReturn(expectedCentralUser);
179 CentralUser actualCentralUser = externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId);
180 assertEquals(actualCentralUser.isActive(), expectedCentralUser.isActive());
184 public void getUserExceptionTest() throws Exception {
185 String reason = getInvalidKeyJson();
186 StringWriter sw = new StringWriter();
187 PrintWriter writer = new PrintWriter(sw);
188 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
189 externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId);
190 String result = sw.getBuffer().toString().trim();
191 assertEquals(reason, result);
195 public void getUserXSSTest() throws Exception {
196 String loginId = "<script ~~~>alert(0%0)</script ~~~>";
197 String expected = getXSSKeyJson();
198 StringWriter sw = new StringWriter();
199 PrintWriter writer = new PrintWriter(sw);
200 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
201 externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId);
202 String actual = sw.getBuffer().toString().trim();
203 assertEquals(expected, actual);
207 public void getV2UserListTest() throws Exception {
208 String expectedCentralUser = "test";
209 String loginId = "test";
210 EPApp app = mockApp();
211 app.setRolesInAAF(true);
212 List<EPApp> appList = new ArrayList<>();
214 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
215 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
216 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
217 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
218 Mockito.when(externalAccessRolesService.getV2UserWithRoles(loginId, mockedRequest.getHeader("uebkey")))
219 .thenReturn(expectedCentralUser);
220 String actualString = externalAccessRolesController.getV2UserList(mockedRequest, mockedResponse, loginId);
221 assertEquals(actualString, expectedCentralUser);
224 @Test(expected = NullPointerException.class)
225 public void getV2UserListExceptionTest() throws Exception {
226 String expectedCentralUser = null;
227 String loginId = "test";
228 EPApp app = mockApp();
229 app.setRolesInAAF(true);
230 List<EPApp> appList = new ArrayList<>();
232 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
233 ResponseEntity<String> response = null;
234 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
235 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
236 Mockito.when(externalAccessRolesService.getV2UserWithRoles(loginId, mockedRequest.getHeader("uebkey")))
237 .thenReturn(expectedCentralUser);
238 String actualString = externalAccessRolesController.getV2UserList(mockedRequest, mockedResponse, loginId);
239 assertEquals(actualString, expectedCentralUser);
243 public void getRolesForAppCentralRoleTest() throws Exception {
244 List<CentralRole> expectedCentralRoleList = new ArrayList<>();
245 List<EPApp> applicationList = new ArrayList<>();
246 List<CentralV2Role> centralV2RoleList = new ArrayList<>();
247 List<CentralRole> centralRoleList = new ArrayList<>();
248 EPApp app = mockApp();
249 app.setRolesInAAF(true);
250 applicationList.add(app);
251 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
252 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
253 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
254 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
255 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
256 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey)))
257 .thenReturn(centralV2RoleList);
258 Mockito.when(externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(centralV2RoleList))
259 .thenReturn(centralRoleList);
260 List<CentralRole> actualCentralRoleList = externalAccessRolesController.getRolesForApp(mockedRequest,
262 assertEquals(actualCentralRoleList.size(), expectedCentralRoleList.size());
265 @Test(expected = NullPointerException.class)
266 public void getRolesForAppCentralRoleExceptionTest() throws Exception {
267 List<EPApp> applicationList = new ArrayList<>();
268 List<CentralV2Role> centralV2RoleList = new ArrayList<>();
269 List<CentralRole> centralRoleList = new ArrayList<>();
270 EPApp app = mockApp();
271 app.setRolesInAAF(true);
272 applicationList.add(app);
273 ResponseEntity<String> response = null;
274 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
275 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
276 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
277 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
278 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey)))
279 .thenReturn(centralV2RoleList);
280 Mockito.when(externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(centralV2RoleList))
281 .thenReturn(centralRoleList);
282 List<CentralRole> actualCentralRoleList = externalAccessRolesController.getRolesForApp(mockedRequest,
284 assertEquals(null, actualCentralRoleList);
288 public void getV2RolesForAppTest() throws Exception {
289 List<CentralRole> expectedCentralRoleList = new ArrayList<>();
290 List<EPApp> applicationList = new ArrayList<>();
291 List<CentralV2Role> centralV2Role = new ArrayList<>();
292 EPApp app = mockApp();
293 app.setRolesInAAF(true);
294 applicationList.add(app);
295 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
296 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
297 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
298 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
299 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
300 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey)))
301 .thenReturn(centralV2Role);
302 List<CentralV2Role> actualCentralV2Role = externalAccessRolesController.getV2RolesForApp(mockedRequest,
304 assertEquals(actualCentralV2Role.size(), expectedCentralRoleList.size());
307 @Test(expected = NullPointerException.class)
308 public void getV2RolesForAppExceptionTest() throws Exception {
309 List<CentralRole> expectedCentralRoleList = new ArrayList<>();
310 List<EPApp> applicationList = new ArrayList<>();
311 List<CentralV2Role> centralV2Role = new ArrayList<>();
312 EPApp app = mockApp();
313 app.setRolesInAAF(true);
314 applicationList.add(app);
315 ResponseEntity<String> response = null;
316 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
317 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
318 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
319 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
320 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey)))
321 .thenReturn(centralV2Role);
322 List<CentralV2Role> actualCentralV2Role = externalAccessRolesController.getV2RolesForApp(mockedRequest,
324 assertEquals(actualCentralV2Role.size(), expectedCentralRoleList.size());
327 @Test(expected = NullPointerException.class)
328 public void getRolesForAppTest() throws Exception {
329 List<EPApp> applicationList = new ArrayList<>();
330 List<CentralV2Role> answer = new ArrayList<>();
331 EPApp app = mockApp();
332 applicationList.add(app);
333 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
334 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
335 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey))).thenReturn(answer);
336 assertEquals(externalAccessRolesController.getRolesForApp(mockedRequest, mockedResponse), null);
339 @Test(expected = NullPointerException.class)
340 public void getRolesForAppExceptionTest() throws Exception {
341 List<EPApp> applicationList = new ArrayList<>();
342 EPApp app = mockApp();
343 applicationList.add(app);
344 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
345 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
346 externalAccessRolesController.getRolesForApp(mockedRequest, mockedResponse);
347 List<CentralV2Role> role = externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey));
348 assertEquals(null, role);
352 public void getRoleFunctionsListTest() throws Exception {
353 List<CentralRole> expectedCentralRoleList = new ArrayList<>();
354 List<CentralRoleFunction> roleFuncList = new ArrayList<>();
355 List<EPApp> applicationList = new ArrayList<>();
356 List<CentralV2RoleFunction> centralV2RoleFunction = new ArrayList<>();
357 EPApp app = mockApp();
358 app.setRolesInAAF(true);
359 applicationList.add(app);
360 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
361 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
362 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
363 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
364 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
365 Mockito.when(externalAccessRolesService.getRoleFuncList(mockedRequest.getHeader("uebkey")))
366 .thenReturn(centralV2RoleFunction);
367 Mockito.when(externalAccessRolesService.convertCentralRoleFunctionToRoleFunctionObject(centralV2RoleFunction))
368 .thenReturn(roleFuncList);
369 List<CentralRoleFunction> actualCentralRoleFunction = externalAccessRolesController
370 .getRoleFunctionsList(mockedRequest, mockedResponse);
371 assertEquals(actualCentralRoleFunction.size(), expectedCentralRoleList.size());
375 public void getRoleFunctionsListExceptionTest() throws Exception {
376 String reason = getInvalidKeyJson();
377 StringWriter sw = new StringWriter();
378 PrintWriter writer = new PrintWriter(sw);
379 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
380 externalAccessRolesController.getRoleFunctionsList(mockedRequest, mockedResponse);
381 String result = sw.getBuffer().toString().trim();
382 assertEquals(reason, result);
386 public void getV2RoleFunctionsListTest() throws Exception {
387 List<CentralV2RoleFunction> expectedCentralV2RoleFunctionList = new ArrayList<>();
388 List<EPApp> applicationList = new ArrayList<>();
389 List<CentralV2RoleFunction> centralV2RoleFunction = new ArrayList<>();
390 EPApp app = mockApp();
391 app.setRolesInAAF(true);
392 applicationList.add(app);
393 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
394 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
395 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
396 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
397 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
398 Mockito.when(externalAccessRolesService.getRoleFuncList(mockedRequest.getHeader("uebkey")))
399 .thenReturn(centralV2RoleFunction);
400 List<CentralV2RoleFunction> actualCentralV2RoleFunctionList = externalAccessRolesController
401 .getV2RoleFunctionsList(mockedRequest, mockedResponse);
402 assertEquals(actualCentralV2RoleFunctionList.size(), expectedCentralV2RoleFunctionList.size());
406 public void getV2RoleFunctionsListExceptionTest() throws Exception {
407 String reason = getInvalidKeyJson();
408 StringWriter sw = new StringWriter();
409 PrintWriter writer = new PrintWriter(sw);
410 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
411 externalAccessRolesController.getV2RoleFunctionsList(mockedRequest, mockedResponse);
412 String result = sw.getBuffer().toString().trim();
413 assertEquals(reason, result);
417 public void getRoleInfoValidationTest() throws Exception {
418 CentralRole expectedCentralRole = null;
419 List<EPApp> applicationList = new ArrayList<>();
421 CentralV2Role centralV2Role = new CentralV2Role.CentralV2RoleBuilder().createCentralV2Role();
422 EPApp app = mockApp();
423 app.setRolesInAAF(true);
424 applicationList.add(app);
425 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
426 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
427 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
428 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
429 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader("uebkey")))
430 .thenReturn(centralV2Role);
431 CentralRole actualCentralRole = externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse,
433 assertEquals(actualCentralRole, expectedCentralRole);
437 public void getRoleInfoTest() throws Exception {
438 String reason = getInvalidKeyJson();
439 StringWriter sw = new StringWriter();
440 PrintWriter writer = new PrintWriter(sw);
441 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
442 CentralV2Role answer = new CentralV2Role.CentralV2RoleBuilder().createCentralV2Role();
444 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader(uebKey)))
446 externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse, roleId);
447 String result = sw.getBuffer().toString().trim();
448 assertEquals(reason, result);
452 public void getRoleInfoExceptionTest() throws Exception {
453 String reason = getInvalidKeyJson();
454 StringWriter sw = new StringWriter();
455 PrintWriter writer = new PrintWriter(sw);
456 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
458 assertNull(externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse, roleId));
459 String result = sw.getBuffer().toString().trim();
460 assertEquals(reason, result);
464 public void getV2RoleInfoValidationTest() throws Exception {
465 CentralV2Role expectedCentralRole = new CentralV2Role.CentralV2RoleBuilder().createCentralV2Role();
466 expectedCentralRole.setActive(false);
467 List<EPApp> applicationList = new ArrayList<>();
469 CentralV2Role centralV2Role = new CentralV2Role.CentralV2RoleBuilder().createCentralV2Role();
470 EPApp app = mockApp();
471 app.setRolesInAAF(true);
472 applicationList.add(app);
473 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
474 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
475 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
476 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
477 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader("uebkey")))
478 .thenReturn(centralV2Role);
479 CentralV2Role actualCentralRole = externalAccessRolesController.getV2RoleInfo(mockedRequest, mockedResponse,
481 assertEquals(actualCentralRole.getActive(), expectedCentralRole.getActive());
485 public void getV2RoleInfoTest() throws Exception {
486 String reason = getInvalidKeyJson();
487 StringWriter sw = new StringWriter();
488 PrintWriter writer = new PrintWriter(sw);
489 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
490 CentralV2Role answer = new CentralV2Role.CentralV2RoleBuilder().createCentralV2Role();
492 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader(uebKey)))
494 externalAccessRolesController.getV2RoleInfo(mockedRequest, mockedResponse, roleId);
495 String result = sw.getBuffer().toString().trim();
496 assertEquals(reason, result);
500 public void getV2RoleInfoExceptionTest() throws Exception {
501 String reason = getInvalidKeyJson();
502 StringWriter sw = new StringWriter();
503 PrintWriter writer = new PrintWriter(sw);
504 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
506 assertNull(externalAccessRolesController.getV2RoleInfo(mockedRequest, mockedResponse, roleId));
507 String result = sw.getBuffer().toString().trim();
508 assertEquals(reason, result);
512 public void getV2RoleFunctionTest() throws Exception {
513 CentralV2RoleFunction expectedCentralV2RoleFunction = new CentralV2RoleFunction();
514 expectedCentralV2RoleFunction.setCode("test");
515 List<EPApp> applicationList = new ArrayList<>();
516 String code = "test";
517 CentralV2RoleFunction centralV2RoleFunction = new CentralV2RoleFunction();
518 centralV2RoleFunction.setCode("test");
519 EPApp app = mockApp();
520 app.setRolesInAAF(true);
521 applicationList.add(app);
522 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
523 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
524 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
525 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
526 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader("uebkey")))
527 .thenReturn(centralV2RoleFunction);
528 CentralV2RoleFunction actualCentralV2RoleFunction = externalAccessRolesController
529 .getV2RoleFunction(mockedRequest, mockedResponse, code);
530 assertEquals(actualCentralV2RoleFunction.getCode(), expectedCentralV2RoleFunction.getCode());
535 public void getV2RoleFunctionNullCheckTest() throws Exception {
536 CentralV2RoleFunction expectedCentralV2RoleFunction = new CentralV2RoleFunction();
537 List<EPApp> applicationList = new ArrayList<>();
538 String code = "test";
539 CentralV2RoleFunction centralV2RoleFunction = null;
540 EPApp app = mockApp();
541 app.setRolesInAAF(true);
542 applicationList.add(app);
543 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
544 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
545 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
546 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
547 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader("uebkey")))
548 .thenReturn(centralV2RoleFunction);
549 CentralV2RoleFunction actualCentralV2RoleFunction = externalAccessRolesController
550 .getV2RoleFunction(mockedRequest, mockedResponse, code);
551 assertEquals(actualCentralV2RoleFunction.getAction(), expectedCentralV2RoleFunction.getAction());
555 public void getV2RoleFunctionExceptionTest() throws Exception {
556 String reason = getInvalidKeyJson();
557 StringWriter sw = new StringWriter();
558 PrintWriter writer = new PrintWriter(sw);
559 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
560 String code = "test";
561 assertNull(externalAccessRolesController.getV2RoleFunction(mockedRequest, mockedResponse, code));
562 String result = sw.getBuffer().toString().trim();
563 assertEquals(reason, result);
567 public void getRoleFunctionTest() throws Exception {
568 EPApp mockApp = mockApp();
569 mockApp.setRolesInAAF(true);
570 List<EPApp> mockAppList = new ArrayList<>();
571 mockAppList.add(mockApp);
572 StringWriter sw = new StringWriter();
573 PrintWriter writer = new PrintWriter(sw);
574 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
575 CentralV2RoleFunction roleFunction1 = new CentralV2RoleFunction();
576 CentralRoleFunction roleFunction2 = new CentralRoleFunction();
577 roleFunction1.setCode("test2");
578 String code = "test_menu";
579 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
580 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(mockAppList);
581 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
582 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(mockAppList.get(0))).thenReturn(response);
583 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader("uebkey")))
584 .thenReturn(roleFunction1);
585 CentralRoleFunction returnedValue = externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse,
587 assertEquals(returnedValue, roleFunction2);
588 String result = sw.getBuffer().toString().trim();
589 assertEquals("", result);
593 public void getRoleFunctionExceptionTest() throws Exception {
594 String reason = getInvalidKeyJson();
595 StringWriter sw = new StringWriter();
596 PrintWriter writer = new PrintWriter(sw);
597 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
598 String code = "test_menu";
599 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader(uebKey)))
600 .thenThrow(httpClientErrorException);
601 assertEquals(new CentralRoleFunction(),
602 externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse, code));
603 String result = sw.getBuffer().toString().trim();
604 assertEquals(reason, result);
608 public void getRoleFunctionXSSTest() throws Exception {
609 String expected = getXSSKeyJson();
610 EPApp mockApp = mockApp();
611 mockApp.setRolesInAAF(true);
612 List<EPApp> mockAppList = new ArrayList<>();
613 mockAppList.add(mockApp);
614 StringWriter sw = new StringWriter();
615 PrintWriter writer = new PrintWriter(sw);
616 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
617 CentralV2RoleFunction roleFunction1 = new CentralV2RoleFunction();
618 CentralRoleFunction roleFunction2 = new CentralRoleFunction();
619 roleFunction1.setCode("test2");
620 String code = "<script>alert(‘XSS’)</script>";
621 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
622 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(mockAppList);
623 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
624 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(mockAppList.get(0))).thenReturn(response);
625 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader("uebkey")))
626 .thenReturn(roleFunction1);
627 CentralRoleFunction returnedValue = externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse,
629 assertEquals(returnedValue, roleFunction2);
630 String result = sw.getBuffer().toString().trim();
631 assertEquals(expected, result);
635 public void saveRoleFunctionIfIsNotDeletedTest() throws Exception {
636 List<EPApp> applicationList = new ArrayList<>();
637 EPApp app = mockApp();
638 applicationList.add(app);
639 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
640 PortalRestResponse<String> portalRestResponse = null;
641 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
642 expectedportalRestResponse.setMessage(null);
643 expectedportalRestResponse.setResponse("Failed");
644 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
646 CentralV2RoleFunction centralV2RoleFunction = new CentralV2RoleFunction();
647 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
648 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
649 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
650 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
651 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(centralV2RoleFunction, app)).thenReturn(false);
652 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, data);
653 assertEquals(portalRestResponse, expectedportalRestResponse);
657 public void saveRoleFunctionExceptionTest() throws Exception {
658 List<EPApp> applicationList = new ArrayList<>();
659 EPApp app = mockApp();
660 app.setRolesInAAF(true);
661 applicationList.add(app);
662 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
663 PortalRestResponse<String> portalRestResponse = null;
664 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
665 expectedportalRestResponse.setMessage("argument \"content\" is null");
666 expectedportalRestResponse.setResponse("Failed");
667 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
668 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
669 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
670 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
671 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
672 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, null);
673 assertEquals(portalRestResponse, expectedportalRestResponse);
677 public void saveRoleFunctionTest() throws Exception {
678 List<EPApp> applicationList = new ArrayList<>();
679 EPUser user = mockUser.mockEPUser();
680 List<EPUser> userList = new ArrayList<>();
682 EPApp app = mockApp();
683 app.setRolesInAAF(true);
684 applicationList.add(app);
685 JSONObject roleFunc = new JSONObject();
686 roleFunc.put("type", "test_type");
687 roleFunc.put("code", "test_instance");
688 roleFunc.put("action", "test_action");
689 roleFunc.put("name", "test_name");
690 ObjectMapper mapper = new ObjectMapper();
691 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
692 CentralV2RoleFunction saveRoleFunc = mapper.readValue(roleFunc.toString(), CentralV2RoleFunction.class);
693 saveRoleFunc.setAppId(app.getId());
694 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
695 PortalRestResponse<String> portalRestResponse = null;
696 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
697 expectedportalRestResponse.setMessage("Successfully saved!");
698 expectedportalRestResponse.setResponse("Success");
699 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
700 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
701 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
702 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
703 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
704 Mockito.when(externalAccessRolesService.getRoleFunction("test_type|test_instance|test_action", app.getUebKey()))
706 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(Matchers.any(CentralV2RoleFunction.class),
707 Matchers.any(EPApp.class))).thenReturn(true);
708 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader(Matchers.anyString())))
709 .thenReturn(userList);
710 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(Matchers.anyString())))
711 .thenReturn(applicationList);
712 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse,
713 roleFunc.toString());
714 assertEquals(portalRestResponse, expectedportalRestResponse);
718 public void saveRoleFunctionXSSTest() throws Exception {
719 List<EPApp> applicationList = new ArrayList<>();
720 EPUser user = mockUser.mockEPUser();
721 List<EPUser> userList = new ArrayList<>();
723 EPApp app = mockApp();
724 app.setRolesInAAF(true);
725 applicationList.add(app);
726 JSONObject roleFunc = new JSONObject();
727 roleFunc.put("type", "<script>alert(“XSS”)</script> ");
728 roleFunc.put("code", "test_instance");
729 roleFunc.put("action", "test_action");
730 roleFunc.put("name", "test_name");
731 ObjectMapper mapper = new ObjectMapper();
732 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
733 CentralV2RoleFunction saveRoleFunc = mapper.readValue(roleFunc.toString(), CentralV2RoleFunction.class);
734 saveRoleFunc.setAppId(app.getId());
735 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
736 PortalRestResponse<String> portalRestResponse = null;
737 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
738 expectedportalRestResponse.setMessage("Failed to roleFunc, not valid data.");
739 expectedportalRestResponse.setResponse("Failed");
740 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
741 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
742 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
743 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
744 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
745 Mockito.when(externalAccessRolesService.getRoleFunction("test_type|test_instance|test_action", app.getUebKey()))
747 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(Matchers.any(CentralV2RoleFunction.class),
748 Matchers.any(EPApp.class))).thenReturn(true);
749 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader(Matchers.anyString())))
750 .thenReturn(userList);
751 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(Matchers.anyString())))
752 .thenReturn(applicationList);
753 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse,
754 roleFunc.toString());
755 assertEquals(expectedportalRestResponse, portalRestResponse);
759 public void deleteRoleFunctionTest() throws Exception {
760 PowerMockito.mockStatic(EcompPortalUtils.class);
761 PowerMockito.mockStatic(SystemProperties.class);
762 PowerMockito.mockStatic(EPCommonSystemProperties.class);
763 PowerMockito.mockStatic(PortalConstants.class);
764 PortalRestResponse<String> portalRestResponse = null;
765 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
766 expectedportalRestResponse.setMessage("Successfully Deleted");
767 expectedportalRestResponse.setResponse("Success");
768 EPUser user = mockUser.mockEPUser();
769 List<EPUser> userList = new ArrayList<>();
771 EPApp app = mockApp();
772 app.setRolesInAAF(true);
773 List<EPApp> appList = new ArrayList<>();
775 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
776 String code = "testNew";
777 Mockito.when(mockedRequest.getHeader("LoginId")).thenReturn("guestT");
778 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
779 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
780 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
781 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
782 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
783 Mockito.when(externalAccessRolesService.deleteCentralRoleFunction(code, app)).thenReturn(true);
784 portalRestResponse = externalAccessRolesController.deleteRoleFunction(mockedRequest, mockedResponse, code);
785 assertEquals(portalRestResponse, expectedportalRestResponse);
789 public void deleteRoleFunctionXSSTest() throws Exception {
790 PowerMockito.mockStatic(EcompPortalUtils.class);
791 PowerMockito.mockStatic(SystemProperties.class);
792 PowerMockito.mockStatic(EPCommonSystemProperties.class);
793 PowerMockito.mockStatic(PortalConstants.class);
794 PortalRestResponse<String> portalRestResponse = null;
795 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
796 expectedportalRestResponse.setMessage("Failed to deleteRoleFunction, not valid data.");
797 expectedportalRestResponse.setResponse("Failed");
798 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
799 EPUser user = mockUser.mockEPUser();
800 List<EPUser> userList = new ArrayList<>();
802 EPApp app = mockApp();
803 app.setRolesInAAF(true);
804 List<EPApp> appList = new ArrayList<>();
806 String code = "<script>alert(‘XSS’)</script>";
807 Mockito.when(mockedRequest.getHeader("LoginId")).thenReturn("guestT");
808 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
809 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
810 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
811 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
812 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
813 Mockito.when(externalAccessRolesService.deleteCentralRoleFunction(code, app)).thenReturn(true);
814 portalRestResponse = externalAccessRolesController.deleteRoleFunction(mockedRequest, mockedResponse, code);
815 assertEquals(portalRestResponse, expectedportalRestResponse);
819 public void getActiveRolesTest() throws Exception {
820 String reason = getInvalidKeyJson();
821 StringWriter sw = new StringWriter();
822 PrintWriter writer = new PrintWriter(sw);
823 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
824 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey))).thenReturn(null);
825 List<CentralRole> expectedCenRole = externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
826 assertNull(expectedCenRole);
827 String result = sw.getBuffer().toString().trim();
828 assertEquals(reason, result);
832 public void getActiveRolesValidationTest() throws Exception {
833 List<CentralRole> expectedRolesList = null;
834 EPApp app = mockApp();
835 app.setRolesInAAF(true);
836 List<EPApp> appList = new ArrayList<>();
838 List<CentralV2Role> cenRoles = new ArrayList<>();
839 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
840 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
841 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
842 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
843 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader("uebkey"))).thenReturn(cenRoles);
844 Mockito.when(externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(cenRoles))
845 .thenReturn(expectedRolesList);
846 List<CentralRole> actualRolesList = externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
847 assertEquals(actualRolesList, expectedRolesList);
851 public void getActiveRolesExceptionTest() throws Exception {
852 String reason = getInvalidKeyJson();
853 StringWriter sw = new StringWriter();
854 PrintWriter writer = new PrintWriter(sw);
855 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
856 externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
857 String result = sw.getBuffer().toString().trim();
858 assertEquals(reason, result);
862 * It return JSON string which has error information
864 * @return JSON String
865 * @throws JsonProcessingException
867 private String getInvalidKeyJson() throws JsonProcessingException {
868 final Map<String, String> uebkeyResponse = new HashMap<>();
870 ObjectMapper mapper = new ObjectMapper();
871 uebkeyResponse.put("error", "Invalid credentials!");
872 reason = mapper.writeValueAsString(uebkeyResponse);
876 private String getXSSKeyJson() throws JsonProcessingException {
877 final Map<String, String> uebkeyResponse = new HashMap<>();
879 ObjectMapper mapper = new ObjectMapper();
880 uebkeyResponse.put("error", "Data is not valid");
881 reason = mapper.writeValueAsString(uebkeyResponse);
886 public void deleteDependcyRoleRecordExceptionTest() {
887 PortalRestResponse<String> portalRestResponse = null;
888 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
889 expectedportalRestResponse.setMessage("Invalid credentials!");
890 expectedportalRestResponse.setResponse("Failed");
891 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
893 portalRestResponse = externalAccessRolesController.deleteDependencyRoleRecord(mockedRequest, mockedResponse,
895 assertEquals(expectedportalRestResponse, portalRestResponse);
899 public void bulkUploadFunctionsTest() throws Exception {
901 Mockito.when(externalAccessRolesService.bulkUploadFunctions(mockedRequest.getHeader(uebKey)))
903 PortalRestResponse<String> portalRestResponse = null;
904 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
905 expectedportalRestResponse.setMessage("Successfully added: 0");
906 expectedportalRestResponse.setResponse("Success");
907 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
908 portalRestResponse = externalAccessRolesController.bulkUploadFunctions(mockedRequest, mockedResponse);
909 assertEquals(portalRestResponse, expectedportalRestResponse);
913 public void bulkUploadFunctionsExceptionTest() throws Exception {
914 Mockito.when(externalAccessRolesService.bulkUploadFunctions(mockedRequest.getHeader(uebKey)))
915 .thenThrow(httpClientErrorException);
916 PortalRestResponse<String> portalRestResponse = null;
917 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
918 expectedportalRestResponse.setMessage("Failed to bulkUploadFunctions");
919 expectedportalRestResponse.setResponse("Failed");
920 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
921 portalRestResponse = externalAccessRolesController.bulkUploadFunctions(mockedRequest, mockedResponse);
922 assertEquals(portalRestResponse, expectedportalRestResponse);
926 public void bulkUploadRolesTest() throws Exception {
928 PortalRestResponse<String> portalRestResponse = null;
929 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
930 expectedportalRestResponse.setMessage("Successfully added: 0");
931 expectedportalRestResponse.setResponse("Success");
932 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
933 Mockito.when(externalAccessRolesService.bulkUploadRoles(mockedRequest.getHeader(uebKey))).thenReturn(result);
934 portalRestResponse = externalAccessRolesController.bulkUploadRoles(mockedRequest, mockedResponse);
935 assertEquals(portalRestResponse, expectedportalRestResponse);
939 public void bulkUploadRolesTestException() throws Exception {
940 Mockito.when(externalAccessRolesService.bulkUploadRoles(mockedRequest.getHeader(uebKey)))
941 .thenThrow(httpClientErrorException);
942 PortalRestResponse<String> portalRestResponse = null;
943 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
944 expectedportalRestResponse.setMessage("Failed to bulkUploadRoles");
945 expectedportalRestResponse.setResponse("Failed");
946 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
947 portalRestResponse = externalAccessRolesController.bulkUploadRoles(mockedRequest, mockedResponse);
948 assertEquals(portalRestResponse, expectedportalRestResponse);
952 public void bulkUploadRoleFunctionsTest() throws Exception {
954 PortalRestResponse<String> portalRestResponse = null;
955 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
956 expectedportalRestResponse.setMessage("Successfully added: 0");
957 expectedportalRestResponse.setResponse("Success");
958 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
959 Mockito.when(externalAccessRolesService.bulkUploadRolesFunctions(mockedRequest.getHeader(uebKey)))
961 portalRestResponse = externalAccessRolesController.bulkUploadRoleFunctions(mockedRequest, mockedResponse);
962 assertEquals(portalRestResponse, expectedportalRestResponse);
966 public void bulkUploadRoleFunctionsException() throws Exception {
967 Mockito.when(externalAccessRolesService.bulkUploadRolesFunctions(mockedRequest.getHeader(uebKey)))
968 .thenThrow(httpClientErrorException);
969 PortalRestResponse<String> portalRestResponse = null;
970 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
971 expectedportalRestResponse.setMessage("Failed to bulkUploadRoleFunctions");
972 expectedportalRestResponse.setResponse("Failed");
973 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
974 portalRestResponse = externalAccessRolesController.bulkUploadRoleFunctions(mockedRequest, mockedResponse);
975 assertEquals(portalRestResponse, expectedportalRestResponse);
979 public void bulkUploadUserRolesTest() throws Exception {
981 PortalRestResponse<String> portalRestResponse = null;
982 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
983 expectedportalRestResponse.setMessage("Successfully added: 0");
984 expectedportalRestResponse.setResponse("Success");
985 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
986 Mockito.when(externalAccessRolesService.bulkUploadUserRoles(mockedRequest.getHeader(uebKey)))
988 portalRestResponse = externalAccessRolesController.bulkUploadUserRoles(mockedRequest, mockedResponse);
989 assertEquals(portalRestResponse, expectedportalRestResponse);
993 public void bulkUploadUserRolesExceptionTest() throws Exception {
994 Mockito.when(externalAccessRolesService.bulkUploadUserRoles(mockedRequest.getHeader(uebKey)))
995 .thenThrow(httpClientErrorException);
996 PortalRestResponse<String> portalRestResponse = null;
997 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
998 expectedportalRestResponse.setMessage("Failed to bulkUploadUserRoles");
999 expectedportalRestResponse.setResponse("Failed");
1000 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1001 portalRestResponse = externalAccessRolesController.bulkUploadUserRoles(mockedRequest, mockedResponse);
1002 assertEquals(portalRestResponse, expectedportalRestResponse);
1006 public void bulkUploadPartnerFunctionsTest() {
1007 PortalRestResponse<String> portalRestResponse = null;
1008 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1009 expectedportalRestResponse.setMessage("Successfully added: '0' functions");
1010 expectedportalRestResponse.setResponse("Success");
1011 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
1012 portalRestResponse = externalAccessRolesController.bulkUploadPartnerFunctions(mockedRequest, mockedResponse);
1013 assertEquals(portalRestResponse, expectedportalRestResponse);
1017 public void bulkUploadPartnerRolesTest() {
1018 PortalRestResponse<String> portalRestResponse = null;
1019 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1020 expectedportalRestResponse.setMessage("Successfully added");
1021 expectedportalRestResponse.setResponse("Success");
1022 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
1023 List<Role> upload = new ArrayList<>();
1024 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoles(mockedRequest, mockedResponse,
1026 assertEquals(portalRestResponse, expectedportalRestResponse);
1030 public void bulkUploadPartnerRolesExceptionTest() {
1031 PortalRestResponse<String> portalRestResponse = null;
1032 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1033 expectedportalRestResponse.setMessage("Successfully added");
1034 expectedportalRestResponse.setResponse("Success");
1035 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
1036 List<Role> upload = new ArrayList<>();
1037 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoles(mockedRequest, mockedResponse,
1039 assertEquals(portalRestResponse, expectedportalRestResponse);
1043 public void getMenuFunctionsTest() throws Exception {
1044 String reason = getInvalidKeyJson();
1045 StringWriter sw = new StringWriter();
1046 PrintWriter writer = new PrintWriter(sw);
1047 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
1048 Mockito.when(externalAccessRolesService.getMenuFunctionsList(mockedRequest.getHeader(uebKey))).thenReturn(null);
1049 List<String> expectedFunctionsList = externalAccessRolesController.getMenuFunctions(mockedRequest,
1051 assertNull(expectedFunctionsList);
1052 String result = sw.getBuffer().toString().trim();
1053 assertEquals(reason, result);
1057 public void getMenuFunctionsExceptionTest() throws Exception {
1058 String reason = getInvalidKeyJson();
1059 StringWriter sw = new StringWriter();
1060 PrintWriter writer = new PrintWriter(sw);
1061 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
1062 Mockito.when(externalAccessRolesService.getMenuFunctionsList(mockedRequest.getHeader(uebKey)))
1063 .thenThrow(httpClientErrorException);
1064 assertNull(externalAccessRolesController.getMenuFunctions(mockedRequest, mockedResponse));
1065 String result = sw.getBuffer().toString().trim();
1066 assertEquals(reason, result);
1070 public void saveRoleExceptionTest() {
1071 Role role = new Role();
1072 PortalRestResponse<String> portalRestResponse = null;
1073 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1074 expectedportalRestResponse.setMessage("Invalid credentials!");
1075 expectedportalRestResponse.setResponse("Failed");
1076 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1077 portalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse, role);
1078 assertEquals(portalRestResponse, expectedportalRestResponse);
1082 public void deleteRoleExceptionTest() {
1083 String role = "TestNew";
1084 PortalRestResponse<String> portalRestResponse = null;
1085 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1086 expectedportalRestResponse.setMessage("Invalid credentials!");
1087 expectedportalRestResponse.setResponse("Failed");
1088 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1089 portalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, role);
1090 assertEquals(portalRestResponse, expectedportalRestResponse);
1094 public void bulkUploadPartnerRoleFunctionsTest() {
1095 PortalRestResponse<String> portalRestResponse = null;
1096 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1097 expectedportalRestResponse.setMessage("Successfully added: '0' role functions");
1098 expectedportalRestResponse.setResponse("Success");
1099 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
1100 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoleFunctions(mockedRequest,
1102 assertEquals(portalRestResponse, expectedportalRestResponse);
1106 public void getUsersOfApplicationTest() throws Exception {
1107 List<EcompUser> users = new ArrayList<>();
1108 EcompUser user = new EcompUser();
1109 user.setOrgUserId("guestT");
1111 StringWriter sw = new StringWriter();
1112 PrintWriter writer = new PrintWriter(sw);
1113 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
1114 List<EPApp> applicationList = new ArrayList<>();
1115 EPApp app = mockApp();
1116 app.setRolesInAAF(true);
1117 applicationList.add(app);
1118 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1119 Mockito.when(externalAccessRolesService.getAllAppUsers(mockedRequest.getHeader(uebKey))).thenReturn(users);
1120 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
1121 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
1122 List<EcompUser> expectedUsers = externalAccessRolesController.getUsersOfApplication(mockedRequest,
1124 assertEquals(expectedUsers, users);
1127 @Test(expected = Exception.class)
1128 public void getUsersOfApplicationExceptionTest() throws Exception {
1129 List<EcompUser> users = new ArrayList<>();
1130 EcompUser user = new EcompUser();
1131 user.setOrgUserId("guestT");
1133 Mockito.when(externalAccessRolesService.getAllAppUsers(mockedRequest.getHeader(uebKey)))
1134 .thenThrow(nullPointerException);
1135 assertNull(externalAccessRolesController.getUsersOfApplication(mockedRequest, mockedResponse));
1138 @Test(expected = NullPointerException.class)
1139 public void deleteRoleV2Test() throws Exception {
1140 List<EPApp> applicationList = new ArrayList<>();
1141 EPApp app = mockApp();
1142 applicationList.add(app);
1143 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1144 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(true,
1146 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(), Matchers.anyString(),
1147 Matchers.anyString())).thenReturn(externalRequestFieldsValidator);
1148 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1149 expectedportalRestResponse.setMessage("Successfully Deleted");
1150 expectedportalRestResponse.setResponse("Success");
1151 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
1152 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest,
1153 mockedResponse, (long) 1);
1154 assertNull(actualResponse);
1158 public void deleteRoleV2InvalidUebKeyTest() throws Exception {
1159 List<EPApp> applicationList = new ArrayList<>();
1160 EPApp app = mockApp();
1161 applicationList.add(app);
1162 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey)))
1163 .thenThrow(new Exception("Invalid credentials!"));
1164 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1165 expectedportalRestResponse.setMessage("Invalid credentials!");
1166 expectedportalRestResponse.setResponse("Failed");
1167 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1168 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest,
1169 mockedResponse, (long) 1);
1170 assertEquals(actualResponse, expectedportalRestResponse);
1174 public void deleteRoleV2InvalidUebKeyWithDiffErrorTest() throws Exception {
1175 List<EPApp> applicationList = new ArrayList<>();
1176 EPApp app = mockApp();
1177 applicationList.add(app);
1178 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey)))
1179 .thenThrow(new Exception("test"));
1180 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1181 expectedportalRestResponse.setMessage("test");
1182 expectedportalRestResponse.setResponse("Failed");
1183 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1184 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest,
1185 mockedResponse, (long) 1);
1186 assertEquals(actualResponse, expectedportalRestResponse);
1189 @Test(expected = NullPointerException.class)
1190 public void deleteRoleV2ExceptionTest() throws Exception {
1191 List<EPApp> applicationList = new ArrayList<>();
1192 EPApp app = mockApp();
1193 applicationList.add(app);
1194 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1195 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false,
1197 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(), Matchers.anyString(),
1198 Matchers.anyString())).thenReturn(externalRequestFieldsValidator);
1199 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1200 expectedportalRestResponse.setMessage("Failed to deleteRole");
1201 expectedportalRestResponse.setResponse("Failed");
1202 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1203 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest,
1204 mockedResponse, (long) 1);
1205 assertEquals(actualResponse, null);
1209 public void getEpUserNullTest() throws Exception {
1210 List<EPApp> applicationList = new ArrayList<>();
1211 EPApp app = mockApp();
1212 app.setUebKey("uebKey");
1213 app.setRolesInAAF(true);
1214 applicationList.add(app);
1215 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1216 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
1217 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
1218 externalAccessRolesController.getEcompUser(mockedRequest, mockedResponse, "test12");
1222 public void getEpUserTest() throws Exception {
1223 List<EPApp> applicationList = new ArrayList<>();
1224 EPApp app = mockApp();
1225 app.setUebKey("uebKey");
1226 app.setRolesInAAF(true);
1227 applicationList.add(app);
1228 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1229 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
1230 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
1231 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\":[]}";
1232 Mockito.when(externalAccessRolesService.getV2UserWithRoles("test12", mockedRequest.getHeader(uebKey)))
1234 User EPuser = new User();
1235 EPuser.setFirstName("test");
1236 Mockito.when(userservice.userMapper(user)).thenReturn(EPuser);
1237 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\":[]}";
1238 assertEquals(externalAccessRolesController.getEcompUser(mockedRequest, mockedResponse, "test12"), res);
1242 public void getEpUserExceptionTest() throws Exception {
1243 List<EPApp> applicationList = new ArrayList<>();
1244 EPApp app = mockApp();
1245 app.setRolesInAAF(true);
1246 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1247 StringWriter sw = new StringWriter();
1248 PrintWriter writer = new PrintWriter(sw);
1249 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
1250 externalAccessRolesController.getEcompUser(mockedRequest, mockedResponse, "test12");
1254 public void getEPRolesOfApplicationTest() throws Exception {
1255 List<EPApp> applicationList = new ArrayList<>();
1256 EPApp app = mockApp();
1257 app.setUebKey("uebKey");
1258 app.setRolesInAAF(true);
1259 applicationList.add(app);
1260 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1261 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
1262 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
1263 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
1264 List<CentralV2Role> cenRoleList = new ArrayList<>();
1265 CentralV2Role role = new CentralV2Role();
1266 role.setName("test");
1267 cenRoleList.add(role);
1268 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey)))
1269 .thenReturn(cenRoleList);
1270 List<EcompRole> ecompRoles = new ArrayList<>();
1271 EcompRole eprole = new EcompRole();
1272 eprole.setName("test");
1273 ecompRoles.add(eprole);
1274 assertEquals(ecompRoles,
1275 externalAccessRolesController.getEcompRolesOfApplication(mockedRequest, mockedResponse));
1279 public void getEPRolesOfApplicationNullTest() throws Exception {
1280 List<EPApp> applicationList = new ArrayList<>();
1281 EPApp app = mockApp();
1282 app.setUebKey("uebKey");
1283 app.setRolesInAAF(true);
1284 applicationList.add(app);
1285 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1286 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
1287 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
1288 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
1289 List<CentralV2Role> cenRoleList = new ArrayList<>();
1290 CentralV2Role role = new CentralV2Role.CentralV2RoleBuilder().createCentralV2Role();
1291 role.setName("test");
1292 cenRoleList.add(role);
1293 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey))).thenReturn(null);
1294 assertNull(externalAccessRolesController.getEcompRolesOfApplication(mockedRequest, mockedResponse));
1298 public void getEPRolesOfApplicationExceptionTest() throws Exception {
1299 List<EPApp> applicationList = new ArrayList<>();
1300 EPApp app = mockApp();
1301 app.setRolesInAAF(true);
1302 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1303 StringWriter sw = new StringWriter();
1304 PrintWriter writer = new PrintWriter(sw);
1305 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
1306 assertNull(externalAccessRolesController.getEcompRolesOfApplication(mockedRequest, mockedResponse));
1310 public void saveRoleTest() throws Exception {
1311 PowerMockito.mockStatic(EcompPortalUtils.class);
1312 PowerMockito.mockStatic(SystemProperties.class);
1313 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1314 PowerMockito.mockStatic(PortalConstants.class);
1315 PortalRestResponse<String> actualPortalRestResponse = null;
1316 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1317 expectedportalRestResponse.setMessage("Successfully Saved");
1318 expectedportalRestResponse.setResponse("Success");
1319 EPUser user = mockUser.mockEPUser();
1320 List<EPUser> userList = new ArrayList<>();
1322 EPApp app = mockApp();
1323 app.setRolesInAAF(true);
1324 List<EPApp> appList = new ArrayList<>();
1326 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
1327 Role role = new Role();
1328 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(true,
1330 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1331 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1332 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1333 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1334 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1335 Mockito.when(externalAccessRolesService.saveRoleForApplication(role, mockedRequest.getHeader("uebkey")))
1336 .thenReturn(externalRequestFieldsValidator);
1337 actualPortalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse, role);
1338 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1342 public void saveRoleNegativeTest() throws Exception {
1343 PowerMockito.mockStatic(EcompPortalUtils.class);
1344 PowerMockito.mockStatic(SystemProperties.class);
1345 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1346 PowerMockito.mockStatic(PortalConstants.class);
1347 PortalRestResponse<String> actualPortalRestResponse = null;
1348 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1349 expectedportalRestResponse.setMessage("Successfully Saved");
1350 expectedportalRestResponse.setResponse("Success");
1351 EPUser user = mockUser.mockEPUser();
1352 List<EPUser> userList = new ArrayList<>();
1354 EPApp app = mockApp();
1355 app.setRolesInAAF(true);
1356 List<EPApp> appList = new ArrayList<>();
1358 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1359 Role role = new Role();
1360 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false,
1362 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1363 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1364 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1365 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1366 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1367 Mockito.when(externalAccessRolesService.saveRoleForApplication(role, mockedRequest.getHeader("uebkey")))
1368 .thenReturn(externalRequestFieldsValidator);
1369 actualPortalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse, role);
1370 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1374 public void saveRole406Test() throws Exception {
1375 PowerMockito.mockStatic(EcompPortalUtils.class);
1376 PowerMockito.mockStatic(SystemProperties.class);
1377 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1378 PowerMockito.mockStatic(PortalConstants.class);
1379 PortalRestResponse<String> actualPortalRestResponse = null;
1380 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1381 expectedportalRestResponse.setMessage("Successfully Saved");
1382 expectedportalRestResponse.setResponse("Failed");
1383 EPUser user = mockUser.mockEPUser();
1384 List<EPUser> userList = new ArrayList<>();
1386 EPApp app = mockApp();
1387 app.setRolesInAAF(true);
1388 List<EPApp> appList = new ArrayList<>();
1390 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1391 Role role = new Role();
1392 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false,
1394 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1395 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1396 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1397 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1398 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1399 Mockito.when(externalAccessRolesService.saveRoleForApplication(role, mockedRequest.getHeader("uebkey")))
1400 .thenReturn(externalRequestFieldsValidator);
1401 actualPortalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse, role);
1402 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1405 @Test(expected = NullPointerException.class)
1406 public void saveRoleNullExceptionTest() throws Exception {
1407 List<EPApp> applicationList = new ArrayList<>();
1408 EPApp app = mockApp();
1409 applicationList.add(app);
1410 Role role = new Role();
1411 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1412 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false,
1414 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(), Matchers.anyString(),
1415 Matchers.anyString())).thenReturn(externalRequestFieldsValidator);
1416 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1417 expectedportalRestResponse.setMessage("Failed to deleteRole");
1418 expectedportalRestResponse.setResponse("Failed");
1419 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1420 PortalRestResponse<String> actualResponse = externalAccessRolesController.saveRole(mockedRequest,
1421 mockedResponse, role);
1422 assertEquals(actualResponse, null);
1426 public void deleteRoleTest() throws Exception {
1427 PowerMockito.mockStatic(EcompPortalUtils.class);
1428 PowerMockito.mockStatic(SystemProperties.class);
1429 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1430 PowerMockito.mockStatic(PortalConstants.class);
1431 PortalRestResponse<String> actualPortalRestResponse = null;
1432 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1433 expectedportalRestResponse.setMessage("Successfully Deleted");
1434 expectedportalRestResponse.setResponse("Success");
1435 EPUser user = mockUser.mockEPUser();
1436 List<EPUser> userList = new ArrayList<>();
1438 EPApp app = mockApp();
1439 app.setRolesInAAF(true);
1440 List<EPApp> appList = new ArrayList<>();
1442 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
1443 String code = "test";
1444 boolean deleteResponse = true;
1445 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1446 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1447 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1448 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1449 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1450 Mockito.when(externalAccessRolesService.deleteRoleForApplication(code, mockedRequest.getHeader("uebkey")))
1451 .thenReturn(deleteResponse);
1452 actualPortalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, code);
1453 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1457 public void deleteRoleXSSTest() throws Exception {
1458 PowerMockito.mockStatic(EcompPortalUtils.class);
1459 PowerMockito.mockStatic(SystemProperties.class);
1460 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1461 PowerMockito.mockStatic(PortalConstants.class);
1462 PortalRestResponse<String> actualPortalRestResponse = null;
1463 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1464 expectedportalRestResponse.setMessage("Failed to deleteRole, not valid data.");
1465 expectedportalRestResponse.setResponse("Failed");
1466 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1467 EPUser user = mockUser.mockEPUser();
1468 List<EPUser> userList = new ArrayList<>();
1470 EPApp app = mockApp();
1471 app.setRolesInAAF(true);
1472 List<EPApp> appList = new ArrayList<>();
1474 String code = "<img src=xss onerror=alert(1)>";
1475 boolean deleteResponse = true;
1476 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1477 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1478 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1479 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1480 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1481 Mockito.when(externalAccessRolesService.deleteRoleForApplication(code, mockedRequest.getHeader("uebkey")))
1482 .thenReturn(deleteResponse);
1483 actualPortalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, code);
1484 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1488 public void deleteRoleNegativeTest() throws Exception {
1489 PowerMockito.mockStatic(EcompPortalUtils.class);
1490 PowerMockito.mockStatic(SystemProperties.class);
1491 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1492 PowerMockito.mockStatic(PortalConstants.class);
1493 PortalRestResponse<String> actualPortalRestResponse = null;
1494 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1495 expectedportalRestResponse.setMessage("Failed to delete Role for 'test");
1496 expectedportalRestResponse.setResponse("Failed");
1497 EPUser user = mockUser.mockEPUser();
1498 List<EPUser> userList = new ArrayList<>();
1500 EPApp app = mockApp();
1501 app.setRolesInAAF(true);
1502 List<EPApp> appList = new ArrayList<>();
1504 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1505 String code = "test";
1506 boolean deleteResponse = false;
1507 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1508 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1509 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1510 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1511 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1512 Mockito.when(externalAccessRolesService.deleteRoleForApplication(code, mockedRequest.getHeader("uebkey")))
1513 .thenReturn(deleteResponse);
1514 actualPortalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, code);
1515 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1519 public void deleteDependcyRoleRecordTest() throws Exception {
1520 ExternalRequestFieldsValidator removeResult = new ExternalRequestFieldsValidator(true, "success");
1521 PortalRestResponse<String> portalRestResponse = null;
1522 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1523 expectedportalRestResponse.setMessage("Invalid credentials!");
1524 expectedportalRestResponse.setResponse("Failed");
1525 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1527 String LoginId = "loginId";
1528 List<EPApp> appList = new ArrayList<>();
1529 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1530 Mockito.when(mockedRequest.getHeader("LoginId")).thenReturn(LoginId);
1531 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1532 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(roleId, mockedRequest.getHeader("uebkey"),
1533 mockedRequest.getHeader("LoginId"))).thenReturn(removeResult);
1534 portalRestResponse = externalAccessRolesController.deleteDependencyRoleRecord(mockedRequest, mockedResponse,
1536 assertEquals(expectedportalRestResponse, portalRestResponse);