2 * ============LICENSE_START==========================================
4 * ===================================================================
5 * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
6 * ===================================================================
8 * Unless otherwise specified, all software contained herein is licensed
9 * under the Apache License, Version 2.0 (the "License");
10 * you may not use this software except in compliance with the License.
11 * You may obtain a copy of the License at
13 * http://www.apache.org/licenses/LICENSE-2.0
15 * Unless required by applicable law or agreed to in writing, software
16 * distributed under the License is distributed on an "AS IS" BASIS,
17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 * See the License for the specific language governing permissions and
19 * limitations under the License.
21 * Unless otherwise specified, all documentation contained herein is licensed
22 * under the Creative Commons License, Attribution 4.0 Intl. (the "License");
23 * you may not use this documentation except in compliance with the License.
24 * You may obtain a copy of the License at
26 * https://creativecommons.org/licenses/by/4.0/
28 * Unless required by applicable law or agreed to in writing, documentation
29 * distributed under the License is distributed on an "AS IS" BASIS,
30 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
31 * See the License for the specific language governing permissions and
32 * limitations under the License.
34 * ============LICENSE_END============================================
38 package org.onap.portalapp.portal.controller;
40 import static org.junit.Assert.assertEquals;
41 import static org.junit.Assert.assertNull;
43 import java.io.PrintWriter;
44 import java.io.StringWriter;
45 import java.util.ArrayList;
46 import java.util.HashMap;
47 import java.util.List;
50 import javax.servlet.http.HttpServletRequest;
51 import javax.servlet.http.HttpServletResponse;
53 import org.json.JSONObject;
54 import org.junit.Before;
55 import org.junit.Test;
56 import org.junit.runner.RunWith;
57 import org.mockito.InjectMocks;
58 import org.mockito.Matchers;
59 import org.mockito.Mock;
60 import org.mockito.Mockito;
61 import org.mockito.MockitoAnnotations;
62 import org.onap.portalapp.portal.core.MockEPUser;
63 import org.onap.portalapp.portal.domain.CentralV2RoleFunction;
64 import org.onap.portalapp.portal.domain.EPApp;
65 import org.onap.portalapp.portal.domain.EPUser;
66 import org.onap.portalapp.portal.ecomp.model.PortalRestResponse;
67 import org.onap.portalapp.portal.ecomp.model.PortalRestStatusEnum;
68 import org.onap.portalapp.portal.framework.MockitoTestSuite;
69 import org.onap.portalapp.portal.service.ExternalAccessRolesService;
70 import org.onap.portalapp.portal.service.ExternalAccessRolesServiceImpl;
71 import org.onap.portalapp.portal.transport.*;
72 import org.onap.portalapp.portal.utils.EPCommonSystemProperties;
73 import org.onap.portalapp.portal.utils.EcompPortalUtils;
74 import org.onap.portalapp.portal.utils.PortalConstants;
75 import org.onap.portalsdk.core.domain.AuditLog;
76 import org.onap.portalsdk.core.domain.Role;
77 import org.onap.portalsdk.core.domain.User;
78 import org.onap.portalsdk.core.restful.domain.EcompRole;
79 import org.onap.portalsdk.core.restful.domain.EcompUser;
80 import org.onap.portalsdk.core.service.AuditService;
81 import org.onap.portalsdk.core.service.UserService;
82 import org.onap.portalsdk.core.service.UserServiceCentalizedImpl;
83 import org.onap.portalsdk.core.util.SystemProperties;
84 import org.powermock.api.mockito.PowerMockito;
85 import org.powermock.core.classloader.annotations.PrepareForTest;
86 import org.powermock.modules.junit4.PowerMockRunner;
87 import org.springframework.http.HttpStatus;
88 import org.springframework.http.ResponseEntity;
89 import org.springframework.web.client.HttpClientErrorException;
91 import com.fasterxml.jackson.core.JsonProcessingException;
92 import com.fasterxml.jackson.databind.DeserializationFeature;
93 import com.fasterxml.jackson.databind.ObjectMapper;
95 @RunWith(PowerMockRunner.class)
96 @PrepareForTest({ EcompPortalUtils.class, PortalConstants.class, SystemProperties.class,
97 EPCommonSystemProperties.class })
98 public class ExternalAccessRolesControllerTest {
100 ExternalAccessRolesService externalAccessRolesService = new ExternalAccessRolesServiceImpl();
102 ExternalAccessRolesController externalAccessRolesController;
104 UserService userservice = new UserServiceCentalizedImpl();
106 AuditService auditService;
109 public void setup() {
110 MockitoAnnotations.initMocks(this);
114 AuditLog auditLog = new AuditLog();
115 MockitoTestSuite mockitoTestSuite = new MockitoTestSuite();
116 HttpServletRequest mockedRequest = mockitoTestSuite.getMockedRequest();
117 HttpServletResponse mockedResponse = mockitoTestSuite.getMockedResponse();
118 NullPointerException nullPointerException = new NullPointerException();
119 HttpClientErrorException httpClientErrorException = new HttpClientErrorException(HttpStatus.BAD_REQUEST, "Failed");
120 MockEPUser mockUser = new MockEPUser();
121 String loginId = "guestT";
122 String uebKey = "testUebKey";
124 public EPApp mockApp() {
125 EPApp app = new EPApp();
127 app.setImageUrl("test");
128 app.setDescription("test");
129 app.setNotes("test");
132 app.setAppRestEndpoint("test");
133 app.setAlternateUrl("test");
135 app.setMlAppName("test");
136 app.setMlAppAdminId("test");
137 app.setUsername("test");
138 app.setAppPassword("test");
140 app.setEnabled(false);
141 app.setUebKey("test");
142 app.setUebSecret("test");
143 app.setUebTopicName("test");
149 public void getUserTest() throws Exception {
150 CentralUser expectedCentralUser =
151 new CentralUser.CentralUserBuilder().setId(null).setCreated(null).setModified(null).setCreatedId(null)
152 .setModifiedId(null).setRowNum(null).setOrgId(null).setManagerId(null).setFirstName(loginId)
153 .setMiddleInitial(loginId).setLastName(loginId).setPhone(loginId).setFax(loginId)
154 .setCellular(loginId).setEmail(loginId).setAddressId(null).setAlertMethodCd(loginId)
155 .setHrid(loginId).setOrgUserId(loginId).setOrgCode(loginId).setAddress1(loginId)
156 .setAddress2(loginId).setCity(loginId).setState(loginId).setZipCode(loginId).setCountry(loginId)
157 .setOrgManagerUserId(loginId).setLocationClli(loginId).setBusinessCountryCode(loginId)
158 .setBusinessCountryName(loginId).setBusinessUnit(loginId).setBusinessUnitName(loginId)
159 .setDepartment(loginId).setDepartmentName(loginId).setCompanyCode(loginId).setCompany(loginId)
160 .setZipCodeSuffix(loginId).setJobTitle(loginId).setCommandChain(loginId).setSiloStatus(loginId)
161 .setCostCenter(loginId).setFinancialLocCode(loginId).setLoginId(loginId).setLoginPwd(loginId)
162 .setLastLoginDate(null).setActive(false).setInternal(false).setSelectedProfileId(null)
163 .setTimeZoneId(null).setOnline(false).setChatId(loginId).setUserApps(null).createCentralUser();
164 String loginId = "test";
165 StringWriter sw = new StringWriter();
166 PrintWriter writer = new PrintWriter(sw);
167 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
168 EPApp app = mockApp();
169 app.setCentralAuth(true);
170 List<EPApp> appList = new ArrayList<>();
172 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
173 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
174 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
175 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
176 Mockito.when(externalAccessRolesService.getUserRoles(loginId, mockedRequest.getHeader("uebkey")))
177 .thenReturn(expectedCentralUser);
178 CentralUser actualCentralUser = externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId);
179 assertEquals(actualCentralUser.isActive(), expectedCentralUser.isActive());
183 public void getUserExceptionTest() throws Exception {
184 String reason = getInvalidKeyJson();
185 StringWriter sw = new StringWriter();
186 PrintWriter writer = new PrintWriter(sw);
187 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
188 externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId);
189 String result = sw.getBuffer().toString().trim();
190 assertEquals(reason, result);
194 public void getUserXSSTest() throws Exception {
195 String loginId = "<script ~~~>alert(0%0)</script ~~~>";
196 String expected = getXSSKeyJson();
197 StringWriter sw = new StringWriter();
198 PrintWriter writer = new PrintWriter(sw);
199 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
200 externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId);
201 String actual = sw.getBuffer().toString().trim();
202 assertEquals(expected, actual);
206 public void getV2UserListTest() throws Exception {
207 String expectedCentralUser = "test";
208 String loginId = "test";
209 EPApp app = mockApp();
210 app.setCentralAuth(true);
211 List<EPApp> appList = new ArrayList<>();
213 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
214 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
215 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
216 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
217 Mockito.when(externalAccessRolesService.getV2UserWithRoles(loginId, mockedRequest.getHeader("uebkey")))
218 .thenReturn(expectedCentralUser);
219 String actualString = externalAccessRolesController.getV2UserList(mockedRequest, mockedResponse, loginId);
220 assertEquals(actualString, expectedCentralUser);
223 @Test(expected = NullPointerException.class)
224 public void getV2UserListExceptionTest() throws Exception {
225 String expectedCentralUser = null;
226 String loginId = "test";
227 EPApp app = mockApp();
228 app.setCentralAuth(true);
229 List<EPApp> appList = new ArrayList<>();
231 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
232 ResponseEntity<String> response = null;
233 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
234 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
235 Mockito.when(externalAccessRolesService.getV2UserWithRoles(loginId, mockedRequest.getHeader("uebkey")))
236 .thenReturn(expectedCentralUser);
237 String actualString = externalAccessRolesController.getV2UserList(mockedRequest, mockedResponse, loginId);
238 assertEquals(actualString, expectedCentralUser);
242 public void getRolesForAppCentralRoleTest() throws Exception {
243 List<CentralRole> expectedCentralRoleList = new ArrayList<>();
244 List<EPApp> applicationList = new ArrayList<>();
245 List<CentralV2Role> centralV2RoleList = new ArrayList<>();
246 List<CentralRole> centralRoleList = new ArrayList<>();
247 EPApp app = mockApp();
248 app.setCentralAuth(true);
249 applicationList.add(app);
250 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
251 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
252 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
253 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
254 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
255 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey)))
256 .thenReturn(centralV2RoleList);
257 Mockito.when(externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(centralV2RoleList))
258 .thenReturn(centralRoleList);
259 List<CentralRole> actualCentralRoleList = externalAccessRolesController.getRolesForApp(mockedRequest,
261 assertEquals(actualCentralRoleList.size(), expectedCentralRoleList.size());
264 @Test(expected = NullPointerException.class)
265 public void getRolesForAppCentralRoleExceptionTest() throws Exception {
266 List<EPApp> applicationList = new ArrayList<>();
267 List<CentralV2Role> centralV2RoleList = new ArrayList<>();
268 List<CentralRole> centralRoleList = new ArrayList<>();
269 EPApp app = mockApp();
270 app.setCentralAuth(true);
271 applicationList.add(app);
272 ResponseEntity<String> response = null;
273 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
274 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
275 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
276 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
277 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey)))
278 .thenReturn(centralV2RoleList);
279 Mockito.when(externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(centralV2RoleList))
280 .thenReturn(centralRoleList);
281 List<CentralRole> actualCentralRoleList = externalAccessRolesController.getRolesForApp(mockedRequest,
283 assertEquals(null, actualCentralRoleList);
287 public void getV2RolesForAppTest() throws Exception {
288 List<CentralRole> expectedCentralRoleList = new ArrayList<>();
289 List<EPApp> applicationList = new ArrayList<>();
290 List<CentralV2Role> centralV2Role = new ArrayList<>();
291 EPApp app = mockApp();
292 app.setCentralAuth(true);
293 applicationList.add(app);
294 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
295 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
296 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
297 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
298 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
299 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey)))
300 .thenReturn(centralV2Role);
301 List<CentralV2Role> actualCentralV2Role = externalAccessRolesController.getV2RolesForApp(mockedRequest,
303 assertEquals(actualCentralV2Role.size(), expectedCentralRoleList.size());
306 @Test(expected = NullPointerException.class)
307 public void getV2RolesForAppExceptionTest() throws Exception {
308 List<CentralRole> expectedCentralRoleList = new ArrayList<>();
309 List<EPApp> applicationList = new ArrayList<>();
310 List<CentralV2Role> centralV2Role = new ArrayList<>();
311 EPApp app = mockApp();
312 app.setCentralAuth(true);
313 applicationList.add(app);
314 ResponseEntity<String> response = null;
315 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
316 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
317 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
318 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
319 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey)))
320 .thenReturn(centralV2Role);
321 List<CentralV2Role> actualCentralV2Role = externalAccessRolesController.getV2RolesForApp(mockedRequest,
323 assertEquals(actualCentralV2Role.size(), expectedCentralRoleList.size());
326 @Test(expected = NullPointerException.class)
327 public void getRolesForAppTest() throws Exception {
328 List<EPApp> applicationList = new ArrayList<>();
329 List<CentralV2Role> answer = new ArrayList<>();
330 EPApp app = mockApp();
331 applicationList.add(app);
332 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
333 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
334 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey))).thenReturn(answer);
335 assertEquals(externalAccessRolesController.getRolesForApp(mockedRequest, mockedResponse), null);
338 @Test(expected = NullPointerException.class)
339 public void getRolesForAppExceptionTest() throws Exception {
340 List<EPApp> applicationList = new ArrayList<>();
341 EPApp app = mockApp();
342 applicationList.add(app);
343 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
344 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
345 externalAccessRolesController.getRolesForApp(mockedRequest, mockedResponse);
346 List<CentralV2Role> role = externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey));
347 assertEquals(null, role);
351 public void getRoleFunctionsListTest() throws Exception {
352 List<CentralRole> expectedCentralRoleList = new ArrayList<>();
353 List<CentralRoleFunction> roleFuncList = new ArrayList<>();
354 List<EPApp> applicationList = new ArrayList<>();
355 List<CentralV2RoleFunction> centralV2RoleFunction = new ArrayList<>();
356 EPApp app = mockApp();
357 app.setCentralAuth(true);
358 applicationList.add(app);
359 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
360 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
361 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
362 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
363 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
364 Mockito.when(externalAccessRolesService.getRoleFuncList(mockedRequest.getHeader("uebkey")))
365 .thenReturn(centralV2RoleFunction);
366 Mockito.when(externalAccessRolesService.convertCentralRoleFunctionToRoleFunctionObject(centralV2RoleFunction))
367 .thenReturn(roleFuncList);
368 List<CentralRoleFunction> actualCentralRoleFunction = externalAccessRolesController
369 .getRoleFunctionsList(mockedRequest, mockedResponse);
370 assertEquals(actualCentralRoleFunction.size(), expectedCentralRoleList.size());
374 public void getRoleFunctionsListExceptionTest() throws Exception {
375 String reason = getInvalidKeyJson();
376 StringWriter sw = new StringWriter();
377 PrintWriter writer = new PrintWriter(sw);
378 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
379 externalAccessRolesController.getRoleFunctionsList(mockedRequest, mockedResponse);
380 String result = sw.getBuffer().toString().trim();
381 assertEquals(reason, result);
385 public void getV2RoleFunctionsListTest() throws Exception {
386 List<CentralV2RoleFunction> expectedCentralV2RoleFunctionList = new ArrayList<>();
387 List<EPApp> applicationList = new ArrayList<>();
388 List<CentralV2RoleFunction> centralV2RoleFunction = new ArrayList<>();
389 EPApp app = mockApp();
390 app.setCentralAuth(true);
391 applicationList.add(app);
392 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
393 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
394 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
395 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
396 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
397 Mockito.when(externalAccessRolesService.getRoleFuncList(mockedRequest.getHeader("uebkey")))
398 .thenReturn(centralV2RoleFunction);
399 List<CentralV2RoleFunction> actualCentralV2RoleFunctionList = externalAccessRolesController
400 .getV2RoleFunctionsList(mockedRequest, mockedResponse);
401 assertEquals(actualCentralV2RoleFunctionList.size(), expectedCentralV2RoleFunctionList.size());
405 public void getV2RoleFunctionsListExceptionTest() throws Exception {
406 String reason = getInvalidKeyJson();
407 StringWriter sw = new StringWriter();
408 PrintWriter writer = new PrintWriter(sw);
409 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
410 externalAccessRolesController.getV2RoleFunctionsList(mockedRequest, mockedResponse);
411 String result = sw.getBuffer().toString().trim();
412 assertEquals(reason, result);
416 public void getRoleInfoValidationTest() throws Exception {
417 CentralRole expectedCentralRole = null;
418 List<EPApp> applicationList = new ArrayList<>();
420 CentralV2Role centralV2Role = new CentralV2Role.CentralV2RoleBuilder().createCentralV2Role();
421 EPApp app = mockApp();
422 app.setCentralAuth(true);
423 applicationList.add(app);
424 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
425 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
426 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
427 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
428 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader("uebkey")))
429 .thenReturn(centralV2Role);
430 CentralRole actualCentralRole = externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse,
432 assertEquals(actualCentralRole, expectedCentralRole);
436 public void getRoleInfoTest() throws Exception {
437 String reason = getInvalidKeyJson();
438 StringWriter sw = new StringWriter();
439 PrintWriter writer = new PrintWriter(sw);
440 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
441 CentralV2Role answer = new CentralV2Role.CentralV2RoleBuilder().createCentralV2Role();
443 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader(uebKey)))
445 externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse, roleId);
446 String result = sw.getBuffer().toString().trim();
447 assertEquals(reason, result);
451 public void getRoleInfoExceptionTest() throws Exception {
452 String reason = getInvalidKeyJson();
453 StringWriter sw = new StringWriter();
454 PrintWriter writer = new PrintWriter(sw);
455 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
457 assertNull(externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse, roleId));
458 String result = sw.getBuffer().toString().trim();
459 assertEquals(reason, result);
463 public void getV2RoleInfoValidationTest() throws Exception {
464 CentralV2Role expectedCentralRole = new CentralV2Role.CentralV2RoleBuilder().createCentralV2Role();
465 expectedCentralRole.setActive(false);
466 List<EPApp> applicationList = new ArrayList<>();
468 CentralV2Role centralV2Role = new CentralV2Role.CentralV2RoleBuilder().createCentralV2Role();
469 EPApp app = mockApp();
470 app.setCentralAuth(true);
471 applicationList.add(app);
472 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
473 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
474 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
475 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
476 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader("uebkey")))
477 .thenReturn(centralV2Role);
478 CentralV2Role actualCentralRole = externalAccessRolesController.getV2RoleInfo(mockedRequest, mockedResponse,
480 assertEquals(actualCentralRole.getActive(), expectedCentralRole.getActive());
484 public void getV2RoleInfoTest() throws Exception {
485 String reason = getInvalidKeyJson();
486 StringWriter sw = new StringWriter();
487 PrintWriter writer = new PrintWriter(sw);
488 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
489 CentralV2Role answer = new CentralV2Role.CentralV2RoleBuilder().createCentralV2Role();
491 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader(uebKey)))
493 externalAccessRolesController.getV2RoleInfo(mockedRequest, mockedResponse, roleId);
494 String result = sw.getBuffer().toString().trim();
495 assertEquals(reason, result);
499 public void getV2RoleInfoExceptionTest() throws Exception {
500 String reason = getInvalidKeyJson();
501 StringWriter sw = new StringWriter();
502 PrintWriter writer = new PrintWriter(sw);
503 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
505 assertNull(externalAccessRolesController.getV2RoleInfo(mockedRequest, mockedResponse, roleId));
506 String result = sw.getBuffer().toString().trim();
507 assertEquals(reason, result);
511 public void getV2RoleFunctionTest() throws Exception {
512 CentralV2RoleFunction expectedCentralV2RoleFunction = new CentralV2RoleFunction();
513 expectedCentralV2RoleFunction.setCode("test");
514 List<EPApp> applicationList = new ArrayList<>();
515 String code = "test";
516 CentralV2RoleFunction centralV2RoleFunction = new CentralV2RoleFunction();
517 centralV2RoleFunction.setCode("test");
518 EPApp app = mockApp();
519 app.setCentralAuth(true);
520 applicationList.add(app);
521 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
522 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
523 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
524 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
525 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader("uebkey")))
526 .thenReturn(centralV2RoleFunction);
527 CentralV2RoleFunction actualCentralV2RoleFunction = externalAccessRolesController
528 .getV2RoleFunction(mockedRequest, mockedResponse, code);
529 assertEquals(actualCentralV2RoleFunction.getCode(), expectedCentralV2RoleFunction.getCode());
534 public void getV2RoleFunctionNullCheckTest() throws Exception {
535 CentralV2RoleFunction expectedCentralV2RoleFunction = new CentralV2RoleFunction();
536 List<EPApp> applicationList = new ArrayList<>();
537 String code = "test";
538 CentralV2RoleFunction centralV2RoleFunction = null;
539 EPApp app = mockApp();
540 app.setCentralAuth(true);
541 applicationList.add(app);
542 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
543 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
544 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
545 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
546 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader("uebkey")))
547 .thenReturn(centralV2RoleFunction);
548 CentralV2RoleFunction actualCentralV2RoleFunction = externalAccessRolesController
549 .getV2RoleFunction(mockedRequest, mockedResponse, code);
550 assertEquals(actualCentralV2RoleFunction.getAction(), expectedCentralV2RoleFunction.getAction());
554 public void getV2RoleFunctionExceptionTest() throws Exception {
555 String reason = getInvalidKeyJson();
556 StringWriter sw = new StringWriter();
557 PrintWriter writer = new PrintWriter(sw);
558 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
559 String code = "test";
560 assertNull(externalAccessRolesController.getV2RoleFunction(mockedRequest, mockedResponse, code));
561 String result = sw.getBuffer().toString().trim();
562 assertEquals(reason, result);
566 public void getRoleFunctionTest() throws Exception {
567 EPApp mockApp = mockApp();
568 mockApp.setCentralAuth(true);
569 List<EPApp> mockAppList = new ArrayList<>();
570 mockAppList.add(mockApp);
571 StringWriter sw = new StringWriter();
572 PrintWriter writer = new PrintWriter(sw);
573 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
574 CentralV2RoleFunction roleFunction1 = new CentralV2RoleFunction();
575 CentralRoleFunction roleFunction2 = new CentralRoleFunction();
576 roleFunction1.setCode("test2");
577 String code = "test_menu";
578 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
579 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(mockAppList);
580 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
581 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(mockAppList.get(0))).thenReturn(response);
582 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader("uebkey")))
583 .thenReturn(roleFunction1);
584 CentralRoleFunction returnedValue = externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse,
586 assertEquals(returnedValue, roleFunction2);
587 String result = sw.getBuffer().toString().trim();
588 assertEquals("", result);
592 public void getRoleFunctionExceptionTest() throws Exception {
593 String reason = getInvalidKeyJson();
594 StringWriter sw = new StringWriter();
595 PrintWriter writer = new PrintWriter(sw);
596 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
597 String code = "test_menu";
598 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader(uebKey)))
599 .thenThrow(httpClientErrorException);
600 assertEquals(new CentralRoleFunction(),
601 externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse, code));
602 String result = sw.getBuffer().toString().trim();
603 assertEquals(reason, result);
607 public void getRoleFunctionXSSTest() throws Exception {
608 String expected = getXSSKeyJson();
609 EPApp mockApp = mockApp();
610 mockApp.setCentralAuth(true);
611 List<EPApp> mockAppList = new ArrayList<>();
612 mockAppList.add(mockApp);
613 StringWriter sw = new StringWriter();
614 PrintWriter writer = new PrintWriter(sw);
615 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
616 CentralV2RoleFunction roleFunction1 = new CentralV2RoleFunction();
617 CentralRoleFunction roleFunction2 = new CentralRoleFunction();
618 roleFunction1.setCode("test2");
619 String code = "<script>alert(‘XSS’)</script>";
620 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
621 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(mockAppList);
622 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
623 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(mockAppList.get(0))).thenReturn(response);
624 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader("uebkey")))
625 .thenReturn(roleFunction1);
626 CentralRoleFunction returnedValue = externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse,
628 assertEquals(returnedValue, roleFunction2);
629 String result = sw.getBuffer().toString().trim();
630 assertEquals(expected, result);
634 public void saveRoleFunctionIfIsNotDeletedTest() throws Exception {
635 List<EPApp> applicationList = new ArrayList<>();
636 EPApp app = mockApp();
637 applicationList.add(app);
638 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
639 PortalRestResponse<String> portalRestResponse = null;
640 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
641 expectedportalRestResponse.setMessage(null);
642 expectedportalRestResponse.setResponse("Failed");
643 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
645 CentralV2RoleFunction centralV2RoleFunction = new CentralV2RoleFunction();
646 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
647 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
648 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
649 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
650 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(centralV2RoleFunction, app)).thenReturn(false);
651 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, data);
652 assertEquals(portalRestResponse, expectedportalRestResponse);
656 public void saveRoleFunctionExceptionTest() throws Exception {
657 List<EPApp> applicationList = new ArrayList<>();
658 EPApp app = mockApp();
659 app.setCentralAuth(true);
660 applicationList.add(app);
661 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
662 PortalRestResponse<String> portalRestResponse = null;
663 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
664 expectedportalRestResponse.setMessage(null);
665 expectedportalRestResponse.setResponse("Failed");
666 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
667 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
668 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
669 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
670 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
671 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, null);
672 assertEquals(portalRestResponse, expectedportalRestResponse);
676 public void saveRoleFunctionTest() throws Exception {
677 List<EPApp> applicationList = new ArrayList<>();
678 EPUser user = mockUser.mockEPUser();
679 List<EPUser> userList = new ArrayList<>();
681 EPApp app = mockApp();
682 app.setCentralAuth(true);
683 applicationList.add(app);
684 JSONObject roleFunc = new JSONObject();
685 roleFunc.put("type", "test_type");
686 roleFunc.put("code", "test_instance");
687 roleFunc.put("action", "test_action");
688 roleFunc.put("name", "test_name");
689 ObjectMapper mapper = new ObjectMapper();
690 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
691 CentralV2RoleFunction saveRoleFunc = mapper.readValue(roleFunc.toString(), CentralV2RoleFunction.class);
692 saveRoleFunc.setAppId(app.getId());
693 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
694 PortalRestResponse<String> portalRestResponse = null;
695 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
696 expectedportalRestResponse.setMessage("Successfully saved!");
697 expectedportalRestResponse.setResponse("Success");
698 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
699 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
700 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
701 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
702 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
703 Mockito.when(externalAccessRolesService.getRoleFunction("test_type|test_instance|test_action", app.getUebKey()))
705 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(Matchers.any(CentralV2RoleFunction.class),
706 Matchers.any(EPApp.class))).thenReturn(true);
707 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader(Matchers.anyString())))
708 .thenReturn(userList);
709 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(Matchers.anyString())))
710 .thenReturn(applicationList);
711 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse,
712 roleFunc.toString());
713 assertEquals(portalRestResponse, expectedportalRestResponse);
717 public void saveRoleFunctionXSSTest() throws Exception {
718 List<EPApp> applicationList = new ArrayList<>();
719 EPUser user = mockUser.mockEPUser();
720 List<EPUser> userList = new ArrayList<>();
722 EPApp app = mockApp();
723 app.setCentralAuth(true);
724 applicationList.add(app);
725 JSONObject roleFunc = new JSONObject();
726 roleFunc.put("type", "<script>alert(“XSS”)</script> ");
727 roleFunc.put("code", "test_instance");
728 roleFunc.put("action", "test_action");
729 roleFunc.put("name", "test_name");
730 ObjectMapper mapper = new ObjectMapper();
731 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
732 CentralV2RoleFunction saveRoleFunc = mapper.readValue(roleFunc.toString(), CentralV2RoleFunction.class);
733 saveRoleFunc.setAppId(app.getId());
734 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
735 PortalRestResponse<String> portalRestResponse = null;
736 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
737 expectedportalRestResponse.setMessage("Failed to roleFunc, not valid data.");
738 expectedportalRestResponse.setResponse("Failed");
739 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
740 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
741 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
742 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
743 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
744 Mockito.when(externalAccessRolesService.getRoleFunction("test_type|test_instance|test_action", app.getUebKey()))
746 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(Matchers.any(CentralV2RoleFunction.class),
747 Matchers.any(EPApp.class))).thenReturn(true);
748 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader(Matchers.anyString())))
749 .thenReturn(userList);
750 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(Matchers.anyString())))
751 .thenReturn(applicationList);
752 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse,
753 roleFunc.toString());
754 assertEquals(expectedportalRestResponse, portalRestResponse);
758 public void deleteRoleFunctionTest() throws Exception {
759 PowerMockito.mockStatic(EcompPortalUtils.class);
760 PowerMockito.mockStatic(SystemProperties.class);
761 PowerMockito.mockStatic(EPCommonSystemProperties.class);
762 PowerMockito.mockStatic(PortalConstants.class);
763 PortalRestResponse<String> portalRestResponse = null;
764 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
765 expectedportalRestResponse.setMessage("Successfully Deleted");
766 expectedportalRestResponse.setResponse("Success");
767 EPUser user = mockUser.mockEPUser();
768 List<EPUser> userList = new ArrayList<>();
770 EPApp app = mockApp();
771 app.setCentralAuth(true);
772 List<EPApp> appList = new ArrayList<>();
774 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
775 String code = "testNew";
776 Mockito.when(mockedRequest.getHeader("LoginId")).thenReturn("guestT");
777 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
778 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
779 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
780 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
781 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
782 Mockito.when(externalAccessRolesService.deleteCentralRoleFunction(code, app)).thenReturn(true);
783 portalRestResponse = externalAccessRolesController.deleteRoleFunction(mockedRequest, mockedResponse, code);
784 assertEquals(portalRestResponse, expectedportalRestResponse);
788 public void deleteRoleFunctionXSSTest() throws Exception {
789 PowerMockito.mockStatic(EcompPortalUtils.class);
790 PowerMockito.mockStatic(SystemProperties.class);
791 PowerMockito.mockStatic(EPCommonSystemProperties.class);
792 PowerMockito.mockStatic(PortalConstants.class);
793 PortalRestResponse<String> portalRestResponse = null;
794 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
795 expectedportalRestResponse.setMessage("Failed to deleteRoleFunction, not valid data.");
796 expectedportalRestResponse.setResponse("Failed");
797 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
798 EPUser user = mockUser.mockEPUser();
799 List<EPUser> userList = new ArrayList<>();
801 EPApp app = mockApp();
802 app.setCentralAuth(true);
803 List<EPApp> appList = new ArrayList<>();
805 String code = "<script>alert(‘XSS’)</script>";
806 Mockito.when(mockedRequest.getHeader("LoginId")).thenReturn("guestT");
807 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
808 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
809 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
810 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
811 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
812 Mockito.when(externalAccessRolesService.deleteCentralRoleFunction(code, app)).thenReturn(true);
813 portalRestResponse = externalAccessRolesController.deleteRoleFunction(mockedRequest, mockedResponse, code);
814 assertEquals(portalRestResponse, expectedportalRestResponse);
818 public void getActiveRolesTest() throws Exception {
819 String reason = getInvalidKeyJson();
820 StringWriter sw = new StringWriter();
821 PrintWriter writer = new PrintWriter(sw);
822 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
823 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey))).thenReturn(null);
824 List<CentralRole> expectedCenRole = externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
825 assertNull(expectedCenRole);
826 String result = sw.getBuffer().toString().trim();
827 assertEquals(reason, result);
831 public void getActiveRolesValidationTest() throws Exception {
832 List<CentralRole> expectedRolesList = null;
833 EPApp app = mockApp();
834 app.setCentralAuth(true);
835 List<EPApp> appList = new ArrayList<>();
837 List<CentralV2Role> cenRoles = new ArrayList<>();
838 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
839 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
840 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
841 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
842 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader("uebkey"))).thenReturn(cenRoles);
843 Mockito.when(externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(cenRoles))
844 .thenReturn(expectedRolesList);
845 List<CentralRole> actualRolesList = externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
846 assertEquals(actualRolesList, expectedRolesList);
850 public void getActiveRolesExceptionTest() throws Exception {
851 String reason = getInvalidKeyJson();
852 StringWriter sw = new StringWriter();
853 PrintWriter writer = new PrintWriter(sw);
854 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
855 externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
856 String result = sw.getBuffer().toString().trim();
857 assertEquals(reason, result);
861 * It return JSON string which has error information
863 * @return JSON String
864 * @throws JsonProcessingException
866 private String getInvalidKeyJson() throws JsonProcessingException {
867 final Map<String, String> uebkeyResponse = new HashMap<>();
869 ObjectMapper mapper = new ObjectMapper();
870 uebkeyResponse.put("error", "Invalid credentials!");
871 reason = mapper.writeValueAsString(uebkeyResponse);
875 private String getXSSKeyJson() throws JsonProcessingException {
876 final Map<String, String> uebkeyResponse = new HashMap<>();
878 ObjectMapper mapper = new ObjectMapper();
879 uebkeyResponse.put("error", "Data is not valid");
880 reason = mapper.writeValueAsString(uebkeyResponse);
885 public void deleteDependcyRoleRecordExceptionTest() {
886 PortalRestResponse<String> portalRestResponse = null;
887 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
888 expectedportalRestResponse.setMessage("Invalid credentials!");
889 expectedportalRestResponse.setResponse("Failed");
890 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
892 portalRestResponse = externalAccessRolesController.deleteDependencyRoleRecord(mockedRequest, mockedResponse,
894 assertEquals(expectedportalRestResponse, portalRestResponse);
898 public void bulkUploadFunctionsTest() throws Exception {
900 Mockito.when(externalAccessRolesService.bulkUploadFunctions(mockedRequest.getHeader(uebKey)))
902 PortalRestResponse<String> portalRestResponse = null;
903 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
904 expectedportalRestResponse.setMessage("Successfully added: 0");
905 expectedportalRestResponse.setResponse("Success");
906 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
907 portalRestResponse = externalAccessRolesController.bulkUploadFunctions(mockedRequest, mockedResponse);
908 assertEquals(portalRestResponse, expectedportalRestResponse);
912 public void bulkUploadFunctionsExceptionTest() throws Exception {
913 Mockito.when(externalAccessRolesService.bulkUploadFunctions(mockedRequest.getHeader(uebKey)))
914 .thenThrow(httpClientErrorException);
915 PortalRestResponse<String> portalRestResponse = null;
916 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
917 expectedportalRestResponse.setMessage("Failed to bulkUploadFunctions");
918 expectedportalRestResponse.setResponse("Failed");
919 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
920 portalRestResponse = externalAccessRolesController.bulkUploadFunctions(mockedRequest, mockedResponse);
921 assertEquals(portalRestResponse, expectedportalRestResponse);
925 public void bulkUploadRolesTest() throws Exception {
927 PortalRestResponse<String> portalRestResponse = null;
928 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
929 expectedportalRestResponse.setMessage("Successfully added: 0");
930 expectedportalRestResponse.setResponse("Success");
931 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
932 Mockito.when(externalAccessRolesService.bulkUploadRoles(mockedRequest.getHeader(uebKey))).thenReturn(result);
933 portalRestResponse = externalAccessRolesController.bulkUploadRoles(mockedRequest, mockedResponse);
934 assertEquals(portalRestResponse, expectedportalRestResponse);
938 public void bulkUploadRolesTestException() throws Exception {
939 Mockito.when(externalAccessRolesService.bulkUploadRoles(mockedRequest.getHeader(uebKey)))
940 .thenThrow(httpClientErrorException);
941 PortalRestResponse<String> portalRestResponse = null;
942 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
943 expectedportalRestResponse.setMessage("Failed to bulkUploadRoles");
944 expectedportalRestResponse.setResponse("Failed");
945 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
946 portalRestResponse = externalAccessRolesController.bulkUploadRoles(mockedRequest, mockedResponse);
947 assertEquals(portalRestResponse, expectedportalRestResponse);
951 public void bulkUploadRoleFunctionsTest() throws Exception {
953 PortalRestResponse<String> portalRestResponse = null;
954 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
955 expectedportalRestResponse.setMessage("Successfully added: 0");
956 expectedportalRestResponse.setResponse("Success");
957 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
958 Mockito.when(externalAccessRolesService.bulkUploadRolesFunctions(mockedRequest.getHeader(uebKey)))
960 portalRestResponse = externalAccessRolesController.bulkUploadRoleFunctions(mockedRequest, mockedResponse);
961 assertEquals(portalRestResponse, expectedportalRestResponse);
965 public void bulkUploadRoleFunctionsException() throws Exception {
966 Mockito.when(externalAccessRolesService.bulkUploadRolesFunctions(mockedRequest.getHeader(uebKey)))
967 .thenThrow(httpClientErrorException);
968 PortalRestResponse<String> portalRestResponse = null;
969 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
970 expectedportalRestResponse.setMessage("Failed to bulkUploadRoleFunctions");
971 expectedportalRestResponse.setResponse("Failed");
972 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
973 portalRestResponse = externalAccessRolesController.bulkUploadRoleFunctions(mockedRequest, mockedResponse);
974 assertEquals(portalRestResponse, expectedportalRestResponse);
978 public void bulkUploadUserRolesTest() throws Exception {
980 PortalRestResponse<String> portalRestResponse = null;
981 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
982 expectedportalRestResponse.setMessage("Successfully added: 0");
983 expectedportalRestResponse.setResponse("Success");
984 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
985 Mockito.when(externalAccessRolesService.bulkUploadUserRoles(mockedRequest.getHeader(uebKey)))
987 portalRestResponse = externalAccessRolesController.bulkUploadUserRoles(mockedRequest, mockedResponse);
988 assertEquals(portalRestResponse, expectedportalRestResponse);
992 public void bulkUploadUserRolesExceptionTest() throws Exception {
993 Mockito.when(externalAccessRolesService.bulkUploadUserRoles(mockedRequest.getHeader(uebKey)))
994 .thenThrow(httpClientErrorException);
995 PortalRestResponse<String> portalRestResponse = null;
996 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
997 expectedportalRestResponse.setMessage("Failed to bulkUploadUserRoles");
998 expectedportalRestResponse.setResponse("Failed");
999 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1000 portalRestResponse = externalAccessRolesController.bulkUploadUserRoles(mockedRequest, mockedResponse);
1001 assertEquals(portalRestResponse, expectedportalRestResponse);
1005 public void bulkUploadPartnerFunctionsTest() {
1006 PortalRestResponse<String> portalRestResponse = null;
1007 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1008 expectedportalRestResponse.setMessage("Successfully added: '0' functions");
1009 expectedportalRestResponse.setResponse("Success");
1010 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
1011 portalRestResponse = externalAccessRolesController.bulkUploadPartnerFunctions(mockedRequest, mockedResponse);
1012 assertEquals(portalRestResponse, expectedportalRestResponse);
1016 public void bulkUploadPartnerRolesTest() {
1017 PortalRestResponse<String> portalRestResponse = null;
1018 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1019 expectedportalRestResponse.setMessage("Successfully added");
1020 expectedportalRestResponse.setResponse("Success");
1021 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
1022 List<Role> upload = new ArrayList<>();
1023 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoles(mockedRequest, mockedResponse,
1025 assertEquals(portalRestResponse, expectedportalRestResponse);
1029 public void bulkUploadPartnerRolesExceptionTest() {
1030 PortalRestResponse<String> portalRestResponse = null;
1031 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1032 expectedportalRestResponse.setMessage("Successfully added");
1033 expectedportalRestResponse.setResponse("Success");
1034 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
1035 List<Role> upload = new ArrayList<>();
1036 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoles(mockedRequest, mockedResponse,
1038 assertEquals(portalRestResponse, expectedportalRestResponse);
1042 public void getMenuFunctionsTest() throws Exception {
1043 String reason = getInvalidKeyJson();
1044 StringWriter sw = new StringWriter();
1045 PrintWriter writer = new PrintWriter(sw);
1046 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
1047 Mockito.when(externalAccessRolesService.getMenuFunctionsList(mockedRequest.getHeader(uebKey))).thenReturn(null);
1048 List<String> expectedFunctionsList = externalAccessRolesController.getMenuFunctions(mockedRequest,
1050 assertNull(expectedFunctionsList);
1051 String result = sw.getBuffer().toString().trim();
1052 assertEquals(reason, result);
1056 public void getMenuFunctionsExceptionTest() throws Exception {
1057 String reason = getInvalidKeyJson();
1058 StringWriter sw = new StringWriter();
1059 PrintWriter writer = new PrintWriter(sw);
1060 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
1061 Mockito.when(externalAccessRolesService.getMenuFunctionsList(mockedRequest.getHeader(uebKey)))
1062 .thenThrow(httpClientErrorException);
1063 assertNull(externalAccessRolesController.getMenuFunctions(mockedRequest, mockedResponse));
1064 String result = sw.getBuffer().toString().trim();
1065 assertEquals(reason, result);
1069 public void saveRoleExceptionTest() {
1070 Role role = new Role();
1071 PortalRestResponse<String> portalRestResponse = null;
1072 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1073 expectedportalRestResponse.setMessage("Invalid credentials!");
1074 expectedportalRestResponse.setResponse("Failed");
1075 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1076 portalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse, role);
1077 assertEquals(portalRestResponse, expectedportalRestResponse);
1081 public void deleteRoleExceptionTest() {
1082 String role = "TestNew";
1083 PortalRestResponse<String> portalRestResponse = null;
1084 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1085 expectedportalRestResponse.setMessage("Invalid credentials!");
1086 expectedportalRestResponse.setResponse("Failed");
1087 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1088 portalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, role);
1089 assertEquals(portalRestResponse, expectedportalRestResponse);
1093 public void bulkUploadPartnerRoleFunctionsTest() {
1094 PortalRestResponse<String> portalRestResponse = null;
1095 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1096 expectedportalRestResponse.setMessage("Successfully added: '0' role functions");
1097 expectedportalRestResponse.setResponse("Success");
1098 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
1099 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoleFunctions(mockedRequest,
1101 assertEquals(portalRestResponse, expectedportalRestResponse);
1105 public void getUsersOfApplicationTest() throws Exception {
1106 List<EcompUser> users = new ArrayList<>();
1107 EcompUser user = new EcompUser();
1108 user.setOrgUserId("guestT");
1110 StringWriter sw = new StringWriter();
1111 PrintWriter writer = new PrintWriter(sw);
1112 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
1113 List<EPApp> applicationList = new ArrayList<>();
1114 EPApp app = mockApp();
1115 app.setCentralAuth(true);
1116 applicationList.add(app);
1117 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1118 Mockito.when(externalAccessRolesService.getAllAppUsers(mockedRequest.getHeader(uebKey))).thenReturn(users);
1119 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
1120 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
1121 List<EcompUser> expectedUsers = externalAccessRolesController.getUsersOfApplication(mockedRequest,
1123 assertEquals(expectedUsers, users);
1126 @Test(expected = Exception.class)
1127 public void getUsersOfApplicationExceptionTest() throws Exception {
1128 List<EcompUser> users = new ArrayList<>();
1129 EcompUser user = new EcompUser();
1130 user.setOrgUserId("guestT");
1132 Mockito.when(externalAccessRolesService.getAllAppUsers(mockedRequest.getHeader(uebKey)))
1133 .thenThrow(nullPointerException);
1134 assertNull(externalAccessRolesController.getUsersOfApplication(mockedRequest, mockedResponse));
1137 @Test(expected = NullPointerException.class)
1138 public void deleteRoleV2Test() throws Exception {
1139 List<EPApp> applicationList = new ArrayList<>();
1140 EPApp app = mockApp();
1141 applicationList.add(app);
1142 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1143 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(true,
1145 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(), Matchers.anyString(),
1146 Matchers.anyString())).thenReturn(externalRequestFieldsValidator);
1147 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1148 expectedportalRestResponse.setMessage("Successfully Deleted");
1149 expectedportalRestResponse.setResponse("Success");
1150 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
1151 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest,
1152 mockedResponse, (long) 1);
1153 assertNull(actualResponse);
1157 public void deleteRoleV2InvalidUebKeyTest() throws Exception {
1158 List<EPApp> applicationList = new ArrayList<>();
1159 EPApp app = mockApp();
1160 applicationList.add(app);
1161 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey)))
1162 .thenThrow(new Exception("Invalid credentials!"));
1163 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1164 expectedportalRestResponse.setMessage("Invalid credentials!");
1165 expectedportalRestResponse.setResponse("Failed");
1166 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1167 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest,
1168 mockedResponse, (long) 1);
1169 assertEquals(actualResponse, expectedportalRestResponse);
1173 public void deleteRoleV2InvalidUebKeyWithDiffErrorTest() throws Exception {
1174 List<EPApp> applicationList = new ArrayList<>();
1175 EPApp app = mockApp();
1176 applicationList.add(app);
1177 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey)))
1178 .thenThrow(new Exception("test"));
1179 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1180 expectedportalRestResponse.setMessage("test");
1181 expectedportalRestResponse.setResponse("Failed");
1182 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1183 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest,
1184 mockedResponse, (long) 1);
1185 assertEquals(actualResponse, expectedportalRestResponse);
1188 @Test(expected = NullPointerException.class)
1189 public void deleteRoleV2ExceptionTest() throws Exception {
1190 List<EPApp> applicationList = new ArrayList<>();
1191 EPApp app = mockApp();
1192 applicationList.add(app);
1193 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1194 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false,
1196 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(), Matchers.anyString(),
1197 Matchers.anyString())).thenReturn(externalRequestFieldsValidator);
1198 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1199 expectedportalRestResponse.setMessage("Failed to deleteRole");
1200 expectedportalRestResponse.setResponse("Failed");
1201 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1202 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest,
1203 mockedResponse, (long) 1);
1204 assertEquals(actualResponse, null);
1208 public void getEpUserNullTest() throws Exception {
1209 List<EPApp> applicationList = new ArrayList<>();
1210 EPApp app = mockApp();
1211 app.setUebKey("uebKey");
1212 app.setCentralAuth(true);
1213 applicationList.add(app);
1214 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1215 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
1216 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
1217 externalAccessRolesController.getEcompUser(mockedRequest, mockedResponse, "test12");
1221 public void getEpUserTest() throws Exception {
1222 List<EPApp> applicationList = new ArrayList<>();
1223 EPApp app = mockApp();
1224 app.setUebKey("uebKey");
1225 app.setCentralAuth(true);
1226 applicationList.add(app);
1227 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1228 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
1229 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
1230 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\":[]}";
1231 Mockito.when(externalAccessRolesService.getV2UserWithRoles("test12", mockedRequest.getHeader(uebKey)))
1233 User EPuser = new User();
1234 EPuser.setFirstName("test");
1235 Mockito.when(userservice.userMapper(user)).thenReturn(EPuser);
1236 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\":[]}";
1237 assertEquals(externalAccessRolesController.getEcompUser(mockedRequest, mockedResponse, "test12"), res);
1241 public void getEpUserExceptionTest() throws Exception {
1242 List<EPApp> applicationList = new ArrayList<>();
1243 EPApp app = mockApp();
1244 app.setCentralAuth(true);
1245 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1246 StringWriter sw = new StringWriter();
1247 PrintWriter writer = new PrintWriter(sw);
1248 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
1249 externalAccessRolesController.getEcompUser(mockedRequest, mockedResponse, "test12");
1253 public void getEPRolesOfApplicationTest() throws Exception {
1254 List<EPApp> applicationList = new ArrayList<>();
1255 EPApp app = mockApp();
1256 app.setUebKey("uebKey");
1257 app.setCentralAuth(true);
1258 applicationList.add(app);
1259 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1260 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
1261 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
1262 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
1263 List<CentralV2Role> cenRoleList = new ArrayList<>();
1264 CentralV2Role role = new CentralV2Role();
1265 role.setName("test");
1266 cenRoleList.add(role);
1267 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey)))
1268 .thenReturn(cenRoleList);
1269 List<EcompRole> ecompRoles = new ArrayList<>();
1270 EcompRole eprole = new EcompRole();
1271 eprole.setName("test");
1272 ecompRoles.add(eprole);
1273 assertEquals(ecompRoles,
1274 externalAccessRolesController.getEcompRolesOfApplication(mockedRequest, mockedResponse));
1278 public void getEPRolesOfApplicationNullTest() throws Exception {
1279 List<EPApp> applicationList = new ArrayList<>();
1280 EPApp app = mockApp();
1281 app.setUebKey("uebKey");
1282 app.setCentralAuth(true);
1283 applicationList.add(app);
1284 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1285 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
1286 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
1287 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
1288 List<CentralV2Role> cenRoleList = new ArrayList<>();
1289 CentralV2Role role = new CentralV2Role.CentralV2RoleBuilder().createCentralV2Role();
1290 role.setName("test");
1291 cenRoleList.add(role);
1292 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey))).thenReturn(null);
1293 assertNull(externalAccessRolesController.getEcompRolesOfApplication(mockedRequest, mockedResponse));
1297 public void getEPRolesOfApplicationExceptionTest() throws Exception {
1298 List<EPApp> applicationList = new ArrayList<>();
1299 EPApp app = mockApp();
1300 app.setCentralAuth(true);
1301 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1302 StringWriter sw = new StringWriter();
1303 PrintWriter writer = new PrintWriter(sw);
1304 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
1305 assertNull(externalAccessRolesController.getEcompRolesOfApplication(mockedRequest, mockedResponse));
1309 public void saveRoleTest() throws Exception {
1310 PowerMockito.mockStatic(EcompPortalUtils.class);
1311 PowerMockito.mockStatic(SystemProperties.class);
1312 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1313 PowerMockito.mockStatic(PortalConstants.class);
1314 PortalRestResponse<String> actualPortalRestResponse = null;
1315 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1316 expectedportalRestResponse.setMessage("Successfully Saved");
1317 expectedportalRestResponse.setResponse("Success");
1318 EPUser user = mockUser.mockEPUser();
1319 List<EPUser> userList = new ArrayList<>();
1321 EPApp app = mockApp();
1322 app.setCentralAuth(true);
1323 List<EPApp> appList = new ArrayList<>();
1325 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
1326 Role role = new Role();
1327 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(true,
1329 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1330 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1331 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1332 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1333 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1334 Mockito.when(externalAccessRolesService.saveRoleForApplication(role, mockedRequest.getHeader("uebkey")))
1335 .thenReturn(externalRequestFieldsValidator);
1336 actualPortalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse, role);
1337 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1341 public void saveRoleNegativeTest() throws Exception {
1342 PowerMockito.mockStatic(EcompPortalUtils.class);
1343 PowerMockito.mockStatic(SystemProperties.class);
1344 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1345 PowerMockito.mockStatic(PortalConstants.class);
1346 PortalRestResponse<String> actualPortalRestResponse = null;
1347 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1348 expectedportalRestResponse.setMessage("Successfully Saved");
1349 expectedportalRestResponse.setResponse("Success");
1350 EPUser user = mockUser.mockEPUser();
1351 List<EPUser> userList = new ArrayList<>();
1353 EPApp app = mockApp();
1354 app.setCentralAuth(true);
1355 List<EPApp> appList = new ArrayList<>();
1357 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1358 Role role = new Role();
1359 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false,
1361 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1362 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1363 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1364 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1365 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1366 Mockito.when(externalAccessRolesService.saveRoleForApplication(role, mockedRequest.getHeader("uebkey")))
1367 .thenReturn(externalRequestFieldsValidator);
1368 actualPortalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse, role);
1369 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1373 public void saveRole406Test() throws Exception {
1374 PowerMockito.mockStatic(EcompPortalUtils.class);
1375 PowerMockito.mockStatic(SystemProperties.class);
1376 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1377 PowerMockito.mockStatic(PortalConstants.class);
1378 PortalRestResponse<String> actualPortalRestResponse = null;
1379 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1380 expectedportalRestResponse.setMessage("Successfully Saved");
1381 expectedportalRestResponse.setResponse("Failed");
1382 EPUser user = mockUser.mockEPUser();
1383 List<EPUser> userList = new ArrayList<>();
1385 EPApp app = mockApp();
1386 app.setCentralAuth(true);
1387 List<EPApp> appList = new ArrayList<>();
1389 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1390 Role role = new Role();
1391 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false,
1393 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1394 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1395 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1396 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1397 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1398 Mockito.when(externalAccessRolesService.saveRoleForApplication(role, mockedRequest.getHeader("uebkey")))
1399 .thenReturn(externalRequestFieldsValidator);
1400 actualPortalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse, role);
1401 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1404 @Test(expected = NullPointerException.class)
1405 public void saveRoleNullExceptionTest() throws Exception {
1406 List<EPApp> applicationList = new ArrayList<>();
1407 EPApp app = mockApp();
1408 applicationList.add(app);
1409 Role role = new Role();
1410 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1411 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false,
1413 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(), Matchers.anyString(),
1414 Matchers.anyString())).thenReturn(externalRequestFieldsValidator);
1415 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1416 expectedportalRestResponse.setMessage("Failed to deleteRole");
1417 expectedportalRestResponse.setResponse("Failed");
1418 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1419 PortalRestResponse<String> actualResponse = externalAccessRolesController.saveRole(mockedRequest,
1420 mockedResponse, role);
1421 assertEquals(actualResponse, null);
1425 public void deleteRoleTest() throws Exception {
1426 PowerMockito.mockStatic(EcompPortalUtils.class);
1427 PowerMockito.mockStatic(SystemProperties.class);
1428 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1429 PowerMockito.mockStatic(PortalConstants.class);
1430 PortalRestResponse<String> actualPortalRestResponse = null;
1431 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1432 expectedportalRestResponse.setMessage("Successfully Deleted");
1433 expectedportalRestResponse.setResponse("Success");
1434 EPUser user = mockUser.mockEPUser();
1435 List<EPUser> userList = new ArrayList<>();
1437 EPApp app = mockApp();
1438 app.setCentralAuth(true);
1439 List<EPApp> appList = new ArrayList<>();
1441 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
1442 String code = "test";
1443 boolean deleteResponse = true;
1444 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1445 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1446 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1447 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1448 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1449 Mockito.when(externalAccessRolesService.deleteRoleForApplication(code, mockedRequest.getHeader("uebkey")))
1450 .thenReturn(deleteResponse);
1451 actualPortalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, code);
1452 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1456 public void deleteRoleXSSTest() throws Exception {
1457 PowerMockito.mockStatic(EcompPortalUtils.class);
1458 PowerMockito.mockStatic(SystemProperties.class);
1459 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1460 PowerMockito.mockStatic(PortalConstants.class);
1461 PortalRestResponse<String> actualPortalRestResponse = null;
1462 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1463 expectedportalRestResponse.setMessage("Failed to deleteRole, not valid data.");
1464 expectedportalRestResponse.setResponse("Failed");
1465 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1466 EPUser user = mockUser.mockEPUser();
1467 List<EPUser> userList = new ArrayList<>();
1469 EPApp app = mockApp();
1470 app.setCentralAuth(true);
1471 List<EPApp> appList = new ArrayList<>();
1473 String code = "<img src=xss onerror=alert(1)>";
1474 boolean deleteResponse = true;
1475 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1476 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1477 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1478 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1479 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1480 Mockito.when(externalAccessRolesService.deleteRoleForApplication(code, mockedRequest.getHeader("uebkey")))
1481 .thenReturn(deleteResponse);
1482 actualPortalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, code);
1483 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1487 public void deleteRoleNegativeTest() throws Exception {
1488 PowerMockito.mockStatic(EcompPortalUtils.class);
1489 PowerMockito.mockStatic(SystemProperties.class);
1490 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1491 PowerMockito.mockStatic(PortalConstants.class);
1492 PortalRestResponse<String> actualPortalRestResponse = null;
1493 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1494 expectedportalRestResponse.setMessage("Failed to delete Role for 'test");
1495 expectedportalRestResponse.setResponse("Failed");
1496 EPUser user = mockUser.mockEPUser();
1497 List<EPUser> userList = new ArrayList<>();
1499 EPApp app = mockApp();
1500 app.setCentralAuth(true);
1501 List<EPApp> appList = new ArrayList<>();
1503 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1504 String code = "test";
1505 boolean deleteResponse = false;
1506 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1507 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1508 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1509 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1510 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1511 Mockito.when(externalAccessRolesService.deleteRoleForApplication(code, mockedRequest.getHeader("uebkey")))
1512 .thenReturn(deleteResponse);
1513 actualPortalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, code);
1514 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1518 public void deleteDependcyRoleRecordTest() throws Exception {
1519 ExternalRequestFieldsValidator removeResult = new ExternalRequestFieldsValidator(true, "success");
1520 PortalRestResponse<String> portalRestResponse = null;
1521 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1522 expectedportalRestResponse.setMessage("Invalid credentials!");
1523 expectedportalRestResponse.setResponse("Failed");
1524 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1526 String LoginId = "loginId";
1527 List<EPApp> appList = new ArrayList<>();
1528 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1529 Mockito.when(mockedRequest.getHeader("LoginId")).thenReturn(LoginId);
1530 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1531 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(roleId, mockedRequest.getHeader("uebkey"),
1532 mockedRequest.getHeader("LoginId"))).thenReturn(removeResult);
1533 portalRestResponse = externalAccessRolesController.deleteDependencyRoleRecord(mockedRequest, mockedResponse,
1535 assertEquals(expectedportalRestResponse, portalRestResponse);