2 * ============LICENSE_START==========================================
4 * ===================================================================
5 * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
6 * ===================================================================
8 * Unless otherwise specified, all software contained herein is licensed
9 * under the Apache License, Version 2.0 (the "License");
10 * you may not use this software except in compliance with the License.
11 * You may obtain a copy of the License at
13 * http://www.apache.org/licenses/LICENSE-2.0
15 * Unless required by applicable law or agreed to in writing, software
16 * distributed under the License is distributed on an "AS IS" BASIS,
17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 * See the License for the specific language governing permissions and
19 * limitations under the License.
21 * Unless otherwise specified, all documentation contained herein is licensed
22 * under the Creative Commons License, Attribution 4.0 Intl. (the "License");
23 * you may not use this documentation except in compliance with the License.
24 * You may obtain a copy of the License at
26 * https://creativecommons.org/licenses/by/4.0/
28 * Unless required by applicable law or agreed to in writing, documentation
29 * distributed under the License is distributed on an "AS IS" BASIS,
30 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
31 * See the License for the specific language governing permissions and
32 * limitations under the License.
34 * ============LICENSE_END============================================
38 package org.onap.portalapp.portal.controller;
40 import static org.junit.Assert.assertEquals;
41 import static org.junit.Assert.assertNull;
43 import java.io.PrintWriter;
44 import java.io.StringWriter;
45 import java.util.ArrayList;
46 import java.util.HashMap;
47 import java.util.List;
50 import javax.servlet.http.HttpServletRequest;
51 import javax.servlet.http.HttpServletResponse;
53 import org.json.JSONObject;
54 import org.junit.Before;
55 import org.junit.Test;
56 import org.junit.runner.RunWith;
57 import org.mockito.InjectMocks;
58 import org.mockito.Matchers;
59 import org.mockito.Mock;
60 import org.mockito.Mockito;
61 import org.mockito.MockitoAnnotations;
62 import org.onap.portalapp.portal.core.MockEPUser;
63 import org.onap.portalapp.portal.domain.CentralV2RoleFunction;
64 import org.onap.portalapp.portal.domain.EPApp;
65 import org.onap.portalapp.portal.domain.EPUser;
66 import org.onap.portalapp.portal.ecomp.model.PortalRestResponse;
67 import org.onap.portalapp.portal.ecomp.model.PortalRestStatusEnum;
68 import org.onap.portalapp.portal.framework.MockitoTestSuite;
69 import org.onap.portalapp.portal.service.ExternalAccessRolesService;
70 import org.onap.portalapp.portal.service.ExternalAccessRolesServiceImpl;
71 import org.onap.portalapp.portal.transport.CentralRole;
72 import org.onap.portalapp.portal.transport.CentralRoleFunction;
73 import org.onap.portalapp.portal.transport.CentralUser;
74 import org.onap.portalapp.portal.transport.CentralV2Role;
75 import org.onap.portalapp.portal.transport.ExternalRequestFieldsValidator;
76 import org.onap.portalapp.portal.utils.EPCommonSystemProperties;
77 import org.onap.portalapp.portal.utils.EcompPortalUtils;
78 import org.onap.portalapp.portal.utils.PortalConstants;
79 import org.onap.portalsdk.core.domain.AuditLog;
80 import org.onap.portalsdk.core.domain.Role;
81 import org.onap.portalsdk.core.domain.User;
82 import org.onap.portalsdk.core.restful.domain.EcompRole;
83 import org.onap.portalsdk.core.restful.domain.EcompUser;
84 import org.onap.portalsdk.core.service.AuditService;
85 import org.onap.portalsdk.core.service.UserService;
86 import org.onap.portalsdk.core.service.UserServiceCentalizedImpl;
87 import org.onap.portalsdk.core.util.SystemProperties;
88 import org.powermock.api.mockito.PowerMockito;
89 import org.powermock.core.classloader.annotations.PrepareForTest;
90 import org.powermock.modules.junit4.PowerMockRunner;
91 import org.springframework.http.HttpStatus;
92 import org.springframework.http.ResponseEntity;
93 import org.springframework.web.client.HttpClientErrorException;
95 import com.fasterxml.jackson.core.JsonProcessingException;
96 import com.fasterxml.jackson.databind.DeserializationFeature;
97 import com.fasterxml.jackson.databind.ObjectMapper;
99 @RunWith(PowerMockRunner.class)
100 @PrepareForTest({ EcompPortalUtils.class, PortalConstants.class, SystemProperties.class,
101 EPCommonSystemProperties.class })
102 public class ExternalAccessRolesControllerTest {
104 ExternalAccessRolesService externalAccessRolesService = new ExternalAccessRolesServiceImpl();
106 ExternalAccessRolesController externalAccessRolesController = new ExternalAccessRolesController();
108 UserService userservice = new UserServiceCentalizedImpl();
110 AuditService auditService;
113 public void setup() {
114 MockitoAnnotations.initMocks(this);
118 AuditLog auditLog = new AuditLog();
119 MockitoTestSuite mockitoTestSuite = new MockitoTestSuite();
120 HttpServletRequest mockedRequest = mockitoTestSuite.getMockedRequest();
121 HttpServletResponse mockedResponse = mockitoTestSuite.getMockedResponse();
122 NullPointerException nullPointerException = new NullPointerException();
123 HttpClientErrorException httpClientErrorException = new HttpClientErrorException(HttpStatus.BAD_REQUEST, "Failed");
124 MockEPUser mockUser = new MockEPUser();
125 String loginId = "guestT";
126 String uebKey = "testUebKey";
128 public EPApp mockApp() {
129 EPApp app = new EPApp();
131 app.setImageUrl("test");
132 app.setDescription("test");
133 app.setNotes("test");
136 app.setAppRestEndpoint("test");
137 app.setAlternateUrl("test");
139 app.setMlAppName("test");
140 app.setMlAppAdminId("test");
141 app.setUsername("test");
142 app.setAppPassword("test");
144 app.setEnabled(false);
145 app.setUebKey("test");
146 app.setUebSecret("test");
147 app.setUebTopicName("test");
153 public void getUserTest() throws Exception {
154 CentralUser expectedCentralUser = new CentralUser(null, null, null, null, null, null, null, null, loginId,
155 loginId, loginId, loginId, loginId, loginId, loginId, null, loginId, loginId, loginId, loginId, loginId,
156 loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId,
157 loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId,
158 loginId, null, false, false, null, null, false, loginId, null);
159 String loginId = "test";
160 StringWriter sw = new StringWriter();
161 PrintWriter writer = new PrintWriter(sw);
162 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
163 EPApp app = mockApp();
164 app.setCentralAuth(true);
165 List<EPApp> appList = new ArrayList<>();
167 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
168 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
169 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
170 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
171 Mockito.when(externalAccessRolesService.getUserRoles(loginId, mockedRequest.getHeader("uebkey")))
172 .thenReturn(expectedCentralUser);
173 CentralUser actualCentralUser = externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId);
174 assertEquals(actualCentralUser.isActive(), expectedCentralUser.isActive());
178 public void getUserExceptionTest() throws Exception {
179 String reason = getInvalidKeyJson();
180 StringWriter sw = new StringWriter();
181 PrintWriter writer = new PrintWriter(sw);
182 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
183 externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId);
184 String result = sw.getBuffer().toString().trim();
185 assertEquals(reason, result);
189 public void getV2UserListTest() throws Exception {
190 String expectedCentralUser = "test";
191 String loginId = "test";
192 EPApp app = mockApp();
193 app.setCentralAuth(true);
194 List<EPApp> appList = new ArrayList<>();
196 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
197 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
198 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
199 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
200 Mockito.when(externalAccessRolesService.getV2UserWithRoles(loginId, mockedRequest.getHeader("uebkey")))
201 .thenReturn(expectedCentralUser);
202 String actualString = externalAccessRolesController.getV2UserList(mockedRequest, mockedResponse, loginId);
203 assertEquals(actualString, expectedCentralUser);
206 @Test(expected = NullPointerException.class)
207 public void getV2UserListExceptionTest() throws Exception {
208 String expectedCentralUser = null;
209 String loginId = "test";
210 EPApp app = mockApp();
211 app.setCentralAuth(true);
212 List<EPApp> appList = new ArrayList<>();
214 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
215 ResponseEntity<String> response = null;
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);
225 public void getRolesForAppCentralRoleTest() throws Exception {
226 List<CentralRole> expectedCentralRoleList = new ArrayList<CentralRole>();
227 List<EPApp> applicationList = new ArrayList<EPApp>();
228 List<CentralV2Role> centralV2RoleList = new ArrayList<>();
229 List<CentralRole> centralRoleList = new ArrayList<>();
230 EPApp app = mockApp();
231 app.setCentralAuth(true);
232 applicationList.add(app);
233 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
234 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
235 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
236 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
237 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
238 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey)))
239 .thenReturn(centralV2RoleList);
240 Mockito.when(externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(centralV2RoleList))
241 .thenReturn(centralRoleList);
242 List<CentralRole> actualCentralRoleList = externalAccessRolesController.getRolesForApp(mockedRequest,
244 assertEquals(actualCentralRoleList.size(), expectedCentralRoleList.size());
247 @Test(expected = NullPointerException.class)
248 public void getRolesForAppCentralRoleExceptionTest() throws Exception {
249 List<EPApp> applicationList = new ArrayList<EPApp>();
250 List<CentralV2Role> centralV2RoleList = new ArrayList<>();
251 List<CentralRole> centralRoleList = new ArrayList<>();
252 EPApp app = mockApp();
253 app.setCentralAuth(true);
254 applicationList.add(app);
255 ResponseEntity<String> response = null;
256 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
257 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
258 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
259 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
260 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey)))
261 .thenReturn(centralV2RoleList);
262 Mockito.when(externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(centralV2RoleList))
263 .thenReturn(centralRoleList);
264 List<CentralRole> actualCentralRoleList = externalAccessRolesController.getRolesForApp(mockedRequest,
266 assertEquals(null, actualCentralRoleList);
270 public void getV2RolesForAppTest() throws Exception {
271 List<CentralRole> expectedCentralRoleList = new ArrayList<CentralRole>();
272 List<EPApp> applicationList = new ArrayList<EPApp>();
273 List<CentralV2Role> centralV2Role = new ArrayList<>();
274 EPApp app = mockApp();
275 app.setCentralAuth(true);
276 applicationList.add(app);
277 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
278 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
279 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
280 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
281 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
282 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey)))
283 .thenReturn(centralV2Role);
284 List<CentralV2Role> actualCentralV2Role = externalAccessRolesController.getV2RolesForApp(mockedRequest,
286 assertEquals(actualCentralV2Role.size(), expectedCentralRoleList.size());
289 @Test(expected = NullPointerException.class)
290 public void getV2RolesForAppExceptionTest() throws Exception {
291 List<CentralRole> expectedCentralRoleList = new ArrayList<CentralRole>();
292 List<EPApp> applicationList = new ArrayList<EPApp>();
293 List<CentralV2Role> centralV2Role = new ArrayList<>();
294 EPApp app = mockApp();
295 app.setCentralAuth(true);
296 applicationList.add(app);
297 ResponseEntity<String> response = null;
298 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
299 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
300 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
301 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
302 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey)))
303 .thenReturn(centralV2Role);
304 List<CentralV2Role> actualCentralV2Role = externalAccessRolesController.getV2RolesForApp(mockedRequest,
306 assertEquals(actualCentralV2Role.size(), expectedCentralRoleList.size());
309 @Test(expected = NullPointerException.class)
310 public void getRolesForAppTest() throws Exception {
311 List<EPApp> applicationList = new ArrayList<EPApp>();
312 List<CentralV2Role> answer = new ArrayList<>();
313 EPApp app = mockApp();
314 applicationList.add(app);
315 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
316 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
317 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey))).thenReturn(answer);
318 assertEquals(externalAccessRolesController.getRolesForApp(mockedRequest, mockedResponse), null);
321 @Test(expected = NullPointerException.class)
322 public void getRolesForAppExceptionTest() throws Exception {
323 List<EPApp> applicationList = new ArrayList<EPApp>();
324 EPApp app = mockApp();
325 applicationList.add(app);
326 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
327 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
328 externalAccessRolesController.getRolesForApp(mockedRequest, mockedResponse);
329 List<CentralV2Role> role = externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey));
330 assertEquals(null, role);
334 public void getRoleFunctionsListTest() throws Exception {
335 List<CentralRole> expectedCentralRoleList = new ArrayList<CentralRole>();
336 List<CentralRoleFunction> roleFuncList = new ArrayList<CentralRoleFunction>();
337 List<EPApp> applicationList = new ArrayList<EPApp>();
338 List<CentralV2RoleFunction> centralV2RoleFunction = new ArrayList<>();
339 EPApp app = mockApp();
340 app.setCentralAuth(true);
341 applicationList.add(app);
342 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
343 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
344 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
345 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
346 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
347 Mockito.when(externalAccessRolesService.getRoleFuncList(mockedRequest.getHeader("uebkey")))
348 .thenReturn(centralV2RoleFunction);
349 Mockito.when(externalAccessRolesService.convertCentralRoleFunctionToRoleFunctionObject(centralV2RoleFunction))
350 .thenReturn(roleFuncList);
351 List<CentralRoleFunction> actualCentralRoleFunction = externalAccessRolesController
352 .getRoleFunctionsList(mockedRequest, mockedResponse);
353 assertEquals(actualCentralRoleFunction.size(), expectedCentralRoleList.size());
357 public void getRoleFunctionsListExceptionTest() throws Exception {
358 String reason = getInvalidKeyJson();
359 StringWriter sw = new StringWriter();
360 PrintWriter writer = new PrintWriter(sw);
361 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
362 externalAccessRolesController.getRoleFunctionsList(mockedRequest, mockedResponse);
363 String result = sw.getBuffer().toString().trim();
364 assertEquals(reason, result);
368 public void getV2RoleFunctionsListTest() throws Exception {
369 List<CentralV2RoleFunction> expectedCentralV2RoleFunctionList = new ArrayList<CentralV2RoleFunction>();
370 List<EPApp> applicationList = new ArrayList<EPApp>();
371 List<CentralV2RoleFunction> centralV2RoleFunction = new ArrayList<>();
372 EPApp app = mockApp();
373 app.setCentralAuth(true);
374 applicationList.add(app);
375 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
376 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
377 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
378 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
379 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
380 Mockito.when(externalAccessRolesService.getRoleFuncList(mockedRequest.getHeader("uebkey")))
381 .thenReturn(centralV2RoleFunction);
382 List<CentralV2RoleFunction> actualCentralV2RoleFunctionList = externalAccessRolesController
383 .getV2RoleFunctionsList(mockedRequest, mockedResponse);
384 assertEquals(actualCentralV2RoleFunctionList.size(), expectedCentralV2RoleFunctionList.size());
388 public void getV2RoleFunctionsListExceptionTest() throws Exception {
389 String reason = getInvalidKeyJson();
390 StringWriter sw = new StringWriter();
391 PrintWriter writer = new PrintWriter(sw);
392 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
393 externalAccessRolesController.getV2RoleFunctionsList(mockedRequest, mockedResponse);
394 String result = sw.getBuffer().toString().trim();
395 assertEquals(reason, result);
399 public void getRoleInfoValidationTest() throws Exception {
400 CentralRole expectedCentralRole = null;
401 List<EPApp> applicationList = new ArrayList<EPApp>();
403 CentralV2Role centralV2Role = new CentralV2Role();
404 EPApp app = mockApp();
405 app.setCentralAuth(true);
406 applicationList.add(app);
407 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
408 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
409 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
410 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
411 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader("uebkey")))
412 .thenReturn(centralV2Role);
413 CentralRole actualCentralRole = externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse,
415 assertEquals(actualCentralRole, expectedCentralRole);
419 public void getRoleInfoTest() throws Exception {
420 String reason = getInvalidKeyJson();
421 StringWriter sw = new StringWriter();
422 PrintWriter writer = new PrintWriter(sw);
423 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
424 CentralV2Role answer = new CentralV2Role();
426 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader(uebKey)))
428 externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse, roleId);
429 String result = sw.getBuffer().toString().trim();
430 assertEquals(reason, result);
434 public void getRoleInfoExceptionTest() throws Exception {
435 String reason = getInvalidKeyJson();
436 StringWriter sw = new StringWriter();
437 PrintWriter writer = new PrintWriter(sw);
438 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
440 assertNull(externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse, roleId));
441 String result = sw.getBuffer().toString().trim();
442 assertEquals(reason, result);
446 public void getV2RoleInfoValidationTest() throws Exception {
447 CentralV2Role expectedCentralRole = new CentralV2Role();
448 expectedCentralRole.setActive(false);
449 List<EPApp> applicationList = new ArrayList<EPApp>();
451 CentralV2Role centralV2Role = new CentralV2Role();
452 EPApp app = mockApp();
453 app.setCentralAuth(true);
454 applicationList.add(app);
455 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
456 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
457 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
458 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
459 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader("uebkey")))
460 .thenReturn(centralV2Role);
461 CentralV2Role actualCentralRole = externalAccessRolesController.getV2RoleInfo(mockedRequest, mockedResponse,
463 assertEquals(actualCentralRole.getActive(), expectedCentralRole.getActive());
467 public void getV2RoleInfoTest() throws Exception {
468 String reason = getInvalidKeyJson();
469 StringWriter sw = new StringWriter();
470 PrintWriter writer = new PrintWriter(sw);
471 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
472 CentralV2Role answer = new CentralV2Role();
474 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader(uebKey)))
476 externalAccessRolesController.getV2RoleInfo(mockedRequest, mockedResponse, roleId);
477 String result = sw.getBuffer().toString().trim();
478 assertEquals(reason, result);
482 public void getV2RoleInfoExceptionTest() throws Exception {
483 String reason = getInvalidKeyJson();
484 StringWriter sw = new StringWriter();
485 PrintWriter writer = new PrintWriter(sw);
486 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
488 assertNull(externalAccessRolesController.getV2RoleInfo(mockedRequest, mockedResponse, roleId));
489 String result = sw.getBuffer().toString().trim();
490 assertEquals(reason, result);
494 public void getV2RoleFunctionTest() throws HttpClientErrorException, Exception {
495 CentralV2RoleFunction expectedCentralV2RoleFunction = new CentralV2RoleFunction();
496 expectedCentralV2RoleFunction.setCode("test");
497 List<EPApp> applicationList = new ArrayList<EPApp>();
498 String code = "test";
499 CentralV2RoleFunction centralV2RoleFunction = new CentralV2RoleFunction();
500 centralV2RoleFunction.setCode("test");
501 EPApp app = mockApp();
502 app.setCentralAuth(true);
503 applicationList.add(app);
504 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
505 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
506 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
507 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
508 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader("uebkey")))
509 .thenReturn(centralV2RoleFunction);
510 CentralV2RoleFunction actualCentralV2RoleFunction = externalAccessRolesController
511 .getV2RoleFunction(mockedRequest, mockedResponse, code);
512 assertEquals(actualCentralV2RoleFunction.getCode(), expectedCentralV2RoleFunction.getCode());
516 public void getV2RoleFunctionNullCheckTest() throws HttpClientErrorException, Exception {
517 CentralV2RoleFunction expectedCentralV2RoleFunction = new CentralV2RoleFunction();
518 List<EPApp> applicationList = new ArrayList<EPApp>();
519 String code = "test";
520 CentralV2RoleFunction centralV2RoleFunction = null;
521 EPApp app = mockApp();
522 app.setCentralAuth(true);
523 applicationList.add(app);
524 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
525 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
526 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
527 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
528 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader("uebkey")))
529 .thenReturn(centralV2RoleFunction);
530 CentralV2RoleFunction actualCentralV2RoleFunction = externalAccessRolesController
531 .getV2RoleFunction(mockedRequest, mockedResponse, code);
532 assertEquals(actualCentralV2RoleFunction.getAction(), expectedCentralV2RoleFunction.getAction());
536 public void getV2RoleFunctionExceptionTest() throws Exception {
537 String reason = getInvalidKeyJson();
538 StringWriter sw = new StringWriter();
539 PrintWriter writer = new PrintWriter(sw);
540 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
541 String code = "test";
542 assertNull(externalAccessRolesController.getV2RoleFunction(mockedRequest, mockedResponse, code));
543 String result = sw.getBuffer().toString().trim();
544 assertEquals(reason, result);
548 public void getRoleFunctionTest() throws Exception {
549 EPApp mockApp = mockApp();
550 mockApp.setCentralAuth(true);
551 List<EPApp> mockAppList = new ArrayList<>();
552 mockAppList.add(mockApp);
553 StringWriter sw = new StringWriter();
554 PrintWriter writer = new PrintWriter(sw);
555 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
556 CentralV2RoleFunction roleFunction1 = new CentralV2RoleFunction();
557 CentralRoleFunction roleFunction2 = new CentralRoleFunction();
558 roleFunction1.setCode("test2");
559 String code = "test_menu";
560 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
561 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(mockAppList);
562 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
563 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(mockAppList.get(0))).thenReturn(response);
564 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader("uebkey")))
565 .thenReturn(roleFunction1);
566 CentralRoleFunction returnedValue = externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse,
568 assertEquals(returnedValue, roleFunction2);
569 String result = sw.getBuffer().toString().trim();
570 assertEquals("", result);
574 public void getRoleFunctionExceptionTest() throws Exception {
575 String reason = getInvalidKeyJson();
576 StringWriter sw = new StringWriter();
577 PrintWriter writer = new PrintWriter(sw);
578 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
579 String code = "test_menu";
580 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader(uebKey)))
581 .thenThrow(httpClientErrorException);
582 assertEquals(new CentralRoleFunction(),
583 externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse, code));
584 String result = sw.getBuffer().toString().trim();
585 assertEquals(reason, result);
589 public void saveRoleFunctionIfIsNotDeletedTest() throws Exception {
590 List<EPApp> applicationList = new ArrayList<EPApp>();
591 EPApp app = mockApp();
592 applicationList.add(app);
593 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
594 PortalRestResponse<String> portalRestResponse = null;
595 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
596 expectedportalRestResponse.setMessage(null);
597 expectedportalRestResponse.setResponse("Failed");
598 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
600 CentralV2RoleFunction centralV2RoleFunction = new CentralV2RoleFunction();
601 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
602 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
603 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
604 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
605 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(centralV2RoleFunction, app)).thenReturn(false);
606 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, data);
607 assertEquals(portalRestResponse, expectedportalRestResponse);
611 public void saveRoleFunctionExceptionTest() throws Exception {
612 List<EPApp> applicationList = new ArrayList<EPApp>();
613 EPApp app = mockApp();
614 app.setCentralAuth(true);
615 applicationList.add(app);
616 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
617 PortalRestResponse<String> portalRestResponse = null;
618 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
619 expectedportalRestResponse.setMessage(null);
620 expectedportalRestResponse.setResponse("Failed");
621 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
622 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
623 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
624 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
625 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
626 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, null);
627 assertEquals(portalRestResponse, expectedportalRestResponse);
630 @SuppressWarnings("static-access")
632 public void saveRoleFunctionTest() throws Exception {
633 List<EPApp> applicationList = new ArrayList<EPApp>();
634 EPUser user = mockUser.mockEPUser();
635 List<EPUser> userList = new ArrayList<>();
637 EPApp app = mockApp();
638 app.setCentralAuth(true);
639 applicationList.add(app);
640 JSONObject roleFunc = new JSONObject();
641 roleFunc.put("type", "test_type");
642 roleFunc.put("code", "test_instance");
643 roleFunc.put("action", "test_action");
644 roleFunc.put("name", "test_name");
645 ObjectMapper mapper = new ObjectMapper();
646 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
647 CentralV2RoleFunction saveRoleFunc = mapper.readValue(roleFunc.toString(), CentralV2RoleFunction.class);
648 saveRoleFunc.setAppId(app.getId());
649 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
650 PortalRestResponse<String> portalRestResponse = null;
651 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
652 expectedportalRestResponse.setMessage("Successfully saved!");
653 expectedportalRestResponse.setResponse("Success");
654 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
655 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
656 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
657 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
658 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
659 Mockito.when(externalAccessRolesService.getRoleFunction("test_type|test_instance|test_action", app.getUebKey()))
661 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(Matchers.any(CentralV2RoleFunction.class),
662 Matchers.any(EPApp.class))).thenReturn(true);
663 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader(Matchers.anyString())))
664 .thenReturn(userList);
665 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(Matchers.anyString())))
666 .thenReturn(applicationList);
667 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse,
668 roleFunc.toString());
669 assertEquals(portalRestResponse, expectedportalRestResponse);
673 public void deleteRoleFunctionTest() throws Exception {
674 PowerMockito.mockStatic(EcompPortalUtils.class);
675 PowerMockito.mockStatic(SystemProperties.class);
676 PowerMockito.mockStatic(EPCommonSystemProperties.class);
677 PowerMockito.mockStatic(PortalConstants.class);
678 PortalRestResponse<String> portalRestResponse = null;
679 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
680 expectedportalRestResponse.setMessage("Successfully Deleted");
681 expectedportalRestResponse.setResponse("Success");
682 EPUser user = mockUser.mockEPUser();
683 List<EPUser> userList = new ArrayList<>();
685 EPApp app = mockApp();
686 app.setCentralAuth(true);
687 List<EPApp> appList = new ArrayList<>();
689 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
690 String code = "testNew";
691 Mockito.when(mockedRequest.getHeader("LoginId")).thenReturn("guestT");
692 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
693 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
694 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
695 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
696 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
697 Mockito.when(externalAccessRolesService.deleteCentralRoleFunction(code, app)).thenReturn(true);
698 portalRestResponse = externalAccessRolesController.deleteRoleFunction(mockedRequest, mockedResponse, code);
699 assertEquals(portalRestResponse, expectedportalRestResponse);
703 public void getActiveRolesTest() throws Exception {
704 String reason = getInvalidKeyJson();
705 StringWriter sw = new StringWriter();
706 PrintWriter writer = new PrintWriter(sw);
707 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
708 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey))).thenReturn(null);
709 List<CentralRole> expectedCenRole = externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
710 assertNull(expectedCenRole);
711 String result = sw.getBuffer().toString().trim();
712 assertEquals(reason, result);
716 public void getActiveRolesValidationTest() throws Exception {
717 List<CentralRole> expectedRolesList = null;
718 EPApp app = mockApp();
719 app.setCentralAuth(true);
720 List<EPApp> appList = new ArrayList<EPApp>();
722 List<CentralV2Role> cenRoles = new ArrayList<CentralV2Role>();
723 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
724 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
725 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
726 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
727 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader("uebkey"))).thenReturn(cenRoles);
728 Mockito.when(externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(cenRoles))
729 .thenReturn(expectedRolesList);
730 List<CentralRole> actualRolesList = externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
731 assertEquals(actualRolesList, expectedRolesList);
735 public void getActiveRolesExceptionTest() throws Exception {
736 String reason = getInvalidKeyJson();
737 StringWriter sw = new StringWriter();
738 PrintWriter writer = new PrintWriter(sw);
739 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
740 externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
741 String result = sw.getBuffer().toString().trim();
742 assertEquals(reason, result);
746 * It return JSON string which has error information
748 * @return JSON String
749 * @throws JsonProcessingException
751 private String getInvalidKeyJson() throws JsonProcessingException {
752 final Map<String, String> uebkeyResponse = new HashMap<>();
754 ObjectMapper mapper = new ObjectMapper();
755 uebkeyResponse.put("error", "Invalid credentials!");
756 reason = mapper.writeValueAsString(uebkeyResponse);
761 public void deleteDependcyRoleRecordExceptionTest() throws Exception {
762 PortalRestResponse<String> portalRestResponse = null;
763 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
764 expectedportalRestResponse.setMessage("Invalid credentials!");
765 expectedportalRestResponse.setResponse("Failed");
766 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
768 portalRestResponse = externalAccessRolesController.deleteDependencyRoleRecord(mockedRequest, mockedResponse,
770 assertEquals(expectedportalRestResponse, portalRestResponse);
774 public void bulkUploadFunctionsTest() throws Exception {
776 Mockito.when(externalAccessRolesService.bulkUploadFunctions(mockedRequest.getHeader(uebKey)))
778 PortalRestResponse<String> portalRestResponse = null;
779 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
780 expectedportalRestResponse.setMessage("Successfully added: 0");
781 expectedportalRestResponse.setResponse("Success");
782 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
783 portalRestResponse = externalAccessRolesController.bulkUploadFunctions(mockedRequest, mockedResponse);
784 assertEquals(portalRestResponse, expectedportalRestResponse);
788 public void bulkUploadFunctionsExceptionTest() throws Exception {
789 Mockito.when(externalAccessRolesService.bulkUploadFunctions(mockedRequest.getHeader(uebKey)))
790 .thenThrow(httpClientErrorException);
791 PortalRestResponse<String> portalRestResponse = null;
792 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
793 expectedportalRestResponse.setMessage("Failed to bulkUploadFunctions");
794 expectedportalRestResponse.setResponse("Failed");
795 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
796 portalRestResponse = externalAccessRolesController.bulkUploadFunctions(mockedRequest, mockedResponse);
797 assertEquals(portalRestResponse, expectedportalRestResponse);
801 public void bulkUploadRolesTest() throws Exception {
803 PortalRestResponse<String> portalRestResponse = null;
804 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
805 expectedportalRestResponse.setMessage("Successfully added: 0");
806 expectedportalRestResponse.setResponse("Success");
807 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
808 Mockito.when(externalAccessRolesService.bulkUploadRoles(mockedRequest.getHeader(uebKey))).thenReturn(result);
809 portalRestResponse = externalAccessRolesController.bulkUploadRoles(mockedRequest, mockedResponse);
810 assertEquals(portalRestResponse, expectedportalRestResponse);
814 public void bulkUploadRolesTestException() throws Exception {
815 Mockito.when(externalAccessRolesService.bulkUploadRoles(mockedRequest.getHeader(uebKey)))
816 .thenThrow(httpClientErrorException);
817 PortalRestResponse<String> portalRestResponse = null;
818 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
819 expectedportalRestResponse.setMessage("Failed to bulkUploadRoles");
820 expectedportalRestResponse.setResponse("Failed");
821 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
822 portalRestResponse = externalAccessRolesController.bulkUploadRoles(mockedRequest, mockedResponse);
823 assertEquals(portalRestResponse, expectedportalRestResponse);
827 public void bulkUploadRoleFunctionsTest() throws Exception {
829 PortalRestResponse<String> portalRestResponse = null;
830 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
831 expectedportalRestResponse.setMessage("Successfully added: 0");
832 expectedportalRestResponse.setResponse("Success");
833 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
834 Mockito.when(externalAccessRolesService.bulkUploadRolesFunctions(mockedRequest.getHeader(uebKey)))
836 portalRestResponse = externalAccessRolesController.bulkUploadRoleFunctions(mockedRequest, mockedResponse);
837 assertEquals(portalRestResponse, expectedportalRestResponse);
841 public void bulkUploadRoleFunctionsException() throws Exception {
842 Mockito.when(externalAccessRolesService.bulkUploadRolesFunctions(mockedRequest.getHeader(uebKey)))
843 .thenThrow(httpClientErrorException);
844 PortalRestResponse<String> portalRestResponse = null;
845 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
846 expectedportalRestResponse.setMessage("Failed to bulkUploadRoleFunctions");
847 expectedportalRestResponse.setResponse("Failed");
848 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
849 portalRestResponse = externalAccessRolesController.bulkUploadRoleFunctions(mockedRequest, mockedResponse);
850 assertEquals(portalRestResponse, expectedportalRestResponse);
854 public void bulkUploadUserRolesTest() throws Exception {
856 PortalRestResponse<String> portalRestResponse = null;
857 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
858 expectedportalRestResponse.setMessage("Successfully added: 0");
859 expectedportalRestResponse.setResponse("Success");
860 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
861 Mockito.when(externalAccessRolesService.bulkUploadUserRoles(mockedRequest.getHeader(uebKey)))
863 portalRestResponse = externalAccessRolesController.bulkUploadUserRoles(mockedRequest, mockedResponse);
864 assertEquals(portalRestResponse, expectedportalRestResponse);
868 public void bulkUploadUserRolesExceptionTest() throws Exception {
869 Mockito.when(externalAccessRolesService.bulkUploadUserRoles(mockedRequest.getHeader(uebKey)))
870 .thenThrow(httpClientErrorException);
871 PortalRestResponse<String> portalRestResponse = null;
872 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
873 expectedportalRestResponse.setMessage("Failed to bulkUploadUserRoles");
874 expectedportalRestResponse.setResponse("Failed");
875 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
876 portalRestResponse = externalAccessRolesController.bulkUploadUserRoles(mockedRequest, mockedResponse);
877 assertEquals(portalRestResponse, expectedportalRestResponse);
881 public void bulkUploadPartnerFunctionsTest() throws Exception {
882 PortalRestResponse<String> portalRestResponse = null;
883 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
884 expectedportalRestResponse.setMessage("Successfully added: '0' functions");
885 expectedportalRestResponse.setResponse("Success");
886 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
887 portalRestResponse = externalAccessRolesController.bulkUploadPartnerFunctions(mockedRequest, mockedResponse);
888 assertEquals(portalRestResponse, expectedportalRestResponse);
892 public void bulkUploadPartnerRolesTest() throws Exception {
893 PortalRestResponse<String> portalRestResponse = null;
894 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
895 expectedportalRestResponse.setMessage("Successfully added");
896 expectedportalRestResponse.setResponse("Success");
897 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
898 List<Role> upload = new ArrayList<>();
899 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoles(mockedRequest, mockedResponse,
901 assertEquals(portalRestResponse, expectedportalRestResponse);
905 public void bulkUploadPartnerRolesExceptionTest() throws Exception {
906 PortalRestResponse<String> portalRestResponse = null;
907 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
908 expectedportalRestResponse.setMessage("Successfully added");
909 expectedportalRestResponse.setResponse("Success");
910 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
911 List<Role> upload = new ArrayList<>();
912 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoles(mockedRequest, mockedResponse,
914 assertEquals(portalRestResponse, expectedportalRestResponse);
918 public void getMenuFunctionsTest() throws Exception {
919 String reason = getInvalidKeyJson();
920 StringWriter sw = new StringWriter();
921 PrintWriter writer = new PrintWriter(sw);
922 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
923 Mockito.when(externalAccessRolesService.getMenuFunctionsList(mockedRequest.getHeader(uebKey))).thenReturn(null);
924 List<String> expectedFunctionsList = externalAccessRolesController.getMenuFunctions(mockedRequest,
926 assertNull(expectedFunctionsList);
927 String result = sw.getBuffer().toString().trim();
928 assertEquals(reason, result);
932 public void getMenuFunctionsExceptionTest() throws Exception {
933 String reason = getInvalidKeyJson();
934 StringWriter sw = new StringWriter();
935 PrintWriter writer = new PrintWriter(sw);
936 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
937 Mockito.when(externalAccessRolesService.getMenuFunctionsList(mockedRequest.getHeader(uebKey)))
938 .thenThrow(httpClientErrorException);
939 assertNull(externalAccessRolesController.getMenuFunctions(mockedRequest, mockedResponse));
940 String result = sw.getBuffer().toString().trim();
941 assertEquals(reason, result);
945 public void saveRoleExceptionTest() throws Exception {
946 Role role = new Role();
947 PortalRestResponse<String> portalRestResponse = null;
948 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
949 expectedportalRestResponse.setMessage("Invalid credentials!");
950 expectedportalRestResponse.setResponse("Failed");
951 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
952 portalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse, role);
953 assertEquals(portalRestResponse, expectedportalRestResponse);
957 public void deleteRoleExceptionTest() throws Exception {
958 String role = "TestNew";
959 PortalRestResponse<String> portalRestResponse = null;
960 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
961 expectedportalRestResponse.setMessage("Invalid credentials!");
962 expectedportalRestResponse.setResponse("Failed");
963 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
964 portalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, role);
965 assertEquals(portalRestResponse, expectedportalRestResponse);
969 public void bulkUploadPartnerRoleFunctionsTest() throws Exception {
970 PortalRestResponse<String> portalRestResponse = null;
971 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
972 expectedportalRestResponse.setMessage("Successfully added: '0' role functions");
973 expectedportalRestResponse.setResponse("Success");
974 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
975 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoleFunctions(mockedRequest,
977 assertEquals(portalRestResponse, expectedportalRestResponse);
981 public void getUsersOfApplicationTest() throws Exception {
982 List<EcompUser> users = new ArrayList<>();
983 EcompUser user = new EcompUser();
984 user.setOrgUserId("guestT");
986 StringWriter sw = new StringWriter();
987 PrintWriter writer = new PrintWriter(sw);
988 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
989 List<EPApp> applicationList = new ArrayList<EPApp>();
990 EPApp app = mockApp();
991 app.setCentralAuth(true);
992 applicationList.add(app);
993 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
994 Mockito.when(externalAccessRolesService.getAllAppUsers(mockedRequest.getHeader(uebKey))).thenReturn(users);
995 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
996 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
997 List<EcompUser> expectedUsers = externalAccessRolesController.getUsersOfApplication(mockedRequest,
999 assertEquals(expectedUsers, users);
1002 @Test(expected = Exception.class)
1003 public void getUsersOfApplicationExceptionTest() throws Exception {
1004 List<EcompUser> users = new ArrayList<>();
1005 EcompUser user = new EcompUser();
1006 user.setOrgUserId("guestT");
1008 Mockito.when(externalAccessRolesService.getAllAppUsers(mockedRequest.getHeader(uebKey)))
1009 .thenThrow(nullPointerException);
1010 assertNull(externalAccessRolesController.getUsersOfApplication(mockedRequest, mockedResponse));
1013 @Test(expected = NullPointerException.class)
1014 public void deleteRoleV2Test() throws Exception {
1015 List<EPApp> applicationList = new ArrayList<EPApp>();
1016 EPApp app = mockApp();
1017 applicationList.add(app);
1018 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1019 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(true,
1021 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(), Matchers.anyString(),
1022 Matchers.anyString())).thenReturn(externalRequestFieldsValidator);
1023 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
1024 expectedportalRestResponse.setMessage("Successfully Deleted");
1025 expectedportalRestResponse.setResponse("Success");
1026 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
1027 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest,
1028 mockedResponse, (long) 1);
1029 assertNull(actualResponse);
1033 public void deleteRoleV2InvalidUebKeyTest() throws Exception {
1034 List<EPApp> applicationList = new ArrayList<EPApp>();
1035 EPApp app = mockApp();
1036 applicationList.add(app);
1037 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey)))
1038 .thenThrow(new Exception("Invalid credentials!"));
1039 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
1040 expectedportalRestResponse.setMessage("Invalid credentials!");
1041 expectedportalRestResponse.setResponse("Failed");
1042 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1043 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest,
1044 mockedResponse, (long) 1);
1045 assertEquals(actualResponse, expectedportalRestResponse);
1049 public void deleteRoleV2InvalidUebKeyWithDiffErrorTest() throws Exception {
1050 List<EPApp> applicationList = new ArrayList<EPApp>();
1051 EPApp app = mockApp();
1052 applicationList.add(app);
1053 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey)))
1054 .thenThrow(new Exception("test"));
1055 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
1056 expectedportalRestResponse.setMessage("test");
1057 expectedportalRestResponse.setResponse("Failed");
1058 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1059 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest,
1060 mockedResponse, (long) 1);
1061 assertEquals(actualResponse, expectedportalRestResponse);
1064 @Test(expected = NullPointerException.class)
1065 public void deleteRoleV2ExceptionTest() throws Exception {
1066 List<EPApp> applicationList = new ArrayList<EPApp>();
1067 EPApp app = mockApp();
1068 applicationList.add(app);
1069 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1070 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false,
1072 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(), Matchers.anyString(),
1073 Matchers.anyString())).thenReturn(externalRequestFieldsValidator);
1074 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
1075 expectedportalRestResponse.setMessage("Failed to deleteRole");
1076 expectedportalRestResponse.setResponse("Failed");
1077 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1078 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest,
1079 mockedResponse, (long) 1);
1080 assertEquals(actualResponse, null);
1084 public void getEpUserNullTest() throws Exception {
1085 List<EPApp> applicationList = new ArrayList<EPApp>();
1086 EPApp app = mockApp();
1087 app.setUebKey("uebKey");
1088 app.setCentralAuth(true);
1089 applicationList.add(app);
1090 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1091 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
1092 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
1093 externalAccessRolesController.getEcompUser(mockedRequest, mockedResponse, "test12");
1097 public void getEpUserTest() throws Exception {
1098 List<EPApp> applicationList = new ArrayList<EPApp>();
1099 EPApp app = mockApp();
1100 app.setUebKey("uebKey");
1101 app.setCentralAuth(true);
1102 applicationList.add(app);
1103 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1104 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
1105 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
1106 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\":[],\"defaultUserApp\":null,\"roles\":[],\"fullName\":\"test null\"}";
1107 Mockito.when(externalAccessRolesService.getV2UserWithRoles("test12", mockedRequest.getHeader(uebKey)))
1109 User EPuser = new User();
1110 EPuser.setFirstName("test");
1111 Mockito.when(userservice.userMapper(user)).thenReturn(EPuser);
1112 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\":[]}";
1113 assertEquals(externalAccessRolesController.getEcompUser(mockedRequest, mockedResponse, "test12"), res);
1117 public void getEpUserExceptionTest() throws Exception {
1118 List<EPApp> applicationList = new ArrayList<EPApp>();
1119 EPApp app = mockApp();
1120 app.setCentralAuth(true);
1121 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1122 StringWriter sw = new StringWriter();
1123 PrintWriter writer = new PrintWriter(sw);
1124 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
1125 externalAccessRolesController.getEcompUser(mockedRequest, mockedResponse, "test12");
1129 public void getEPRolesOfApplicationTest() throws Exception {
1130 List<EPApp> applicationList = new ArrayList<EPApp>();
1131 EPApp app = mockApp();
1132 app.setUebKey("uebKey");
1133 app.setCentralAuth(true);
1134 applicationList.add(app);
1135 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1136 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
1137 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
1138 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
1139 List<CentralV2Role> cenRoleList = new ArrayList<>();
1140 CentralV2Role role = new CentralV2Role();
1141 role.setName("test");
1142 cenRoleList.add(role);
1143 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey)))
1144 .thenReturn(cenRoleList);
1145 List<EcompRole> ecompRoles = new ArrayList<>();
1146 EcompRole eprole = new EcompRole();
1147 eprole.setName("test");
1148 ecompRoles.add(eprole);
1149 assertEquals(ecompRoles,
1150 externalAccessRolesController.getEcompRolesOfApplication(mockedRequest, mockedResponse));
1154 public void getEPRolesOfApplicationNullTest() throws Exception {
1155 List<EPApp> applicationList = new ArrayList<EPApp>();
1156 EPApp app = mockApp();
1157 app.setUebKey("uebKey");
1158 app.setCentralAuth(true);
1159 applicationList.add(app);
1160 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1161 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
1162 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
1163 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
1164 List<CentralV2Role> cenRoleList = new ArrayList<>();
1165 CentralV2Role role = new CentralV2Role();
1166 role.setName("test");
1167 cenRoleList.add(role);
1168 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey))).thenReturn(null);
1169 assertNull(externalAccessRolesController.getEcompRolesOfApplication(mockedRequest, mockedResponse));
1173 public void getEPRolesOfApplicationExceptionTest() throws Exception {
1174 List<EPApp> applicationList = new ArrayList<EPApp>();
1175 EPApp app = mockApp();
1176 app.setCentralAuth(true);
1177 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1178 StringWriter sw = new StringWriter();
1179 PrintWriter writer = new PrintWriter(sw);
1180 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
1181 assertNull(externalAccessRolesController.getEcompRolesOfApplication(mockedRequest, mockedResponse));
1185 public void saveRoleTest() throws Exception {
1186 PowerMockito.mockStatic(EcompPortalUtils.class);
1187 PowerMockito.mockStatic(SystemProperties.class);
1188 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1189 PowerMockito.mockStatic(PortalConstants.class);
1190 PortalRestResponse<String> actualPortalRestResponse = null;
1191 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
1192 expectedportalRestResponse.setMessage("Successfully Saved");
1193 expectedportalRestResponse.setResponse("Success");
1194 EPUser user = mockUser.mockEPUser();
1195 List<EPUser> userList = new ArrayList<>();
1197 EPApp app = mockApp();
1198 app.setCentralAuth(true);
1199 List<EPApp> appList = new ArrayList<>();
1201 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
1202 Role role = new Role();
1203 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(true,
1205 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1206 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1207 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1208 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1209 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1210 Mockito.when(externalAccessRolesService.saveRoleForApplication(role, mockedRequest.getHeader("uebkey")))
1211 .thenReturn(externalRequestFieldsValidator);
1212 actualPortalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse, role);
1213 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1217 public void saveRoleNegativeTest() throws Exception {
1218 PowerMockito.mockStatic(EcompPortalUtils.class);
1219 PowerMockito.mockStatic(SystemProperties.class);
1220 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1221 PowerMockito.mockStatic(PortalConstants.class);
1222 PortalRestResponse<String> actualPortalRestResponse = null;
1223 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
1224 expectedportalRestResponse.setMessage("Successfully Saved");
1225 expectedportalRestResponse.setResponse("Success");
1226 EPUser user = mockUser.mockEPUser();
1227 List<EPUser> userList = new ArrayList<>();
1229 EPApp app = mockApp();
1230 app.setCentralAuth(true);
1231 List<EPApp> appList = new ArrayList<>();
1233 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1234 Role role = new Role();
1235 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false,
1237 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1238 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1239 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1240 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1241 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1242 Mockito.when(externalAccessRolesService.saveRoleForApplication(role, mockedRequest.getHeader("uebkey")))
1243 .thenReturn(externalRequestFieldsValidator);
1244 actualPortalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse, role);
1245 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1249 public void saveRole406Test() throws Exception {
1250 PowerMockito.mockStatic(EcompPortalUtils.class);
1251 PowerMockito.mockStatic(SystemProperties.class);
1252 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1253 PowerMockito.mockStatic(PortalConstants.class);
1254 PortalRestResponse<String> actualPortalRestResponse = null;
1255 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
1256 expectedportalRestResponse.setMessage("Successfully Saved");
1257 expectedportalRestResponse.setResponse("Failed");
1258 EPUser user = mockUser.mockEPUser();
1259 List<EPUser> userList = new ArrayList<>();
1261 EPApp app = mockApp();
1262 app.setCentralAuth(true);
1263 List<EPApp> appList = new ArrayList<>();
1265 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1266 Role role = new Role();
1267 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false,
1269 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1270 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1271 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1272 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1273 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1274 Mockito.when(externalAccessRolesService.saveRoleForApplication(role, mockedRequest.getHeader("uebkey")))
1275 .thenReturn(externalRequestFieldsValidator);
1276 actualPortalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse, role);
1277 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1280 @Test(expected = NullPointerException.class)
1281 public void saveRoleNullExceptionTest() throws Exception {
1282 List<EPApp> applicationList = new ArrayList<EPApp>();
1283 EPApp app = mockApp();
1284 applicationList.add(app);
1285 Role role = new Role();
1286 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1287 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false,
1289 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(), Matchers.anyString(),
1290 Matchers.anyString())).thenReturn(externalRequestFieldsValidator);
1291 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
1292 expectedportalRestResponse.setMessage("Failed to deleteRole");
1293 expectedportalRestResponse.setResponse("Failed");
1294 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1295 PortalRestResponse<String> actualResponse = externalAccessRolesController.saveRole(mockedRequest,
1296 mockedResponse, role);
1297 assertEquals(actualResponse, null);
1301 public void deleteRoleTest() throws Exception {
1302 PowerMockito.mockStatic(EcompPortalUtils.class);
1303 PowerMockito.mockStatic(SystemProperties.class);
1304 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1305 PowerMockito.mockStatic(PortalConstants.class);
1306 PortalRestResponse<String> actualPortalRestResponse = null;
1307 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
1308 expectedportalRestResponse.setMessage("Successfully Deleted");
1309 expectedportalRestResponse.setResponse("Success");
1310 EPUser user = mockUser.mockEPUser();
1311 List<EPUser> userList = new ArrayList<>();
1313 EPApp app = mockApp();
1314 app.setCentralAuth(true);
1315 List<EPApp> appList = new ArrayList<>();
1317 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
1318 String code = "test";
1319 boolean deleteResponse = true;
1320 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1321 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1322 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1323 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1324 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1325 Mockito.when(externalAccessRolesService.deleteRoleForApplication(code, mockedRequest.getHeader("uebkey")))
1326 .thenReturn(deleteResponse);
1327 actualPortalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, code);
1328 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1332 public void deleteRoleNegativeTest() throws Exception {
1333 PowerMockito.mockStatic(EcompPortalUtils.class);
1334 PowerMockito.mockStatic(SystemProperties.class);
1335 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1336 PowerMockito.mockStatic(PortalConstants.class);
1337 PortalRestResponse<String> actualPortalRestResponse = null;
1338 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
1339 expectedportalRestResponse.setMessage("Failed to delete Role for 'test");
1340 expectedportalRestResponse.setResponse("Failed");
1341 EPUser user = mockUser.mockEPUser();
1342 List<EPUser> userList = new ArrayList<>();
1344 EPApp app = mockApp();
1345 app.setCentralAuth(true);
1346 List<EPApp> appList = new ArrayList<>();
1348 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1349 String code = "test";
1350 boolean deleteResponse = false;
1351 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1352 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1353 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1354 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1355 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1356 Mockito.when(externalAccessRolesService.deleteRoleForApplication(code, mockedRequest.getHeader("uebkey")))
1357 .thenReturn(deleteResponse);
1358 actualPortalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, code);
1359 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1363 public void deleteDependcyRoleRecordTest() throws Exception {
1364 ExternalRequestFieldsValidator removeResult = new ExternalRequestFieldsValidator(true, "success");
1365 PortalRestResponse<String> portalRestResponse = null;
1366 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
1367 expectedportalRestResponse.setMessage("Invalid credentials!");
1368 expectedportalRestResponse.setResponse("Failed");
1369 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1371 String LoginId = "loginId";
1372 List<EPApp> appList = new ArrayList<EPApp>();
1373 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1374 Mockito.when(mockedRequest.getHeader("LoginId")).thenReturn(LoginId);
1375 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1376 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(roleId, mockedRequest.getHeader("uebkey"),
1377 mockedRequest.getHeader("LoginId"))).thenReturn(removeResult);
1378 portalRestResponse = externalAccessRolesController.deleteDependencyRoleRecord(mockedRequest, mockedResponse,
1380 assertEquals(expectedportalRestResponse, portalRestResponse);