2 * ============LICENSE_START==========================================
4 * ===================================================================
5 * Copyright (C) 2017 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;
41 import static org.junit.Assert.assertEquals;
42 import static org.junit.Assert.assertNull;
44 import java.io.PrintWriter;
45 import java.io.StringWriter;
46 import java.util.ArrayList;
47 import java.util.HashMap;
48 import java.util.List;
51 import javax.servlet.http.HttpServletRequest;
52 import javax.servlet.http.HttpServletResponse;
54 import org.json.JSONObject;
55 import org.junit.Before;
56 import org.junit.Test;
57 import org.junit.runner.RunWith;
58 import org.mockito.InjectMocks;
59 import org.mockito.Matchers;
60 import org.mockito.Mock;
61 import org.mockito.Mockito;
62 import org.mockito.MockitoAnnotations;
63 import org.onap.portalapp.portal.core.MockEPUser;
64 import org.onap.portalapp.portal.domain.CentralV2RoleFunction;
65 import org.onap.portalapp.portal.domain.EPApp;
66 import org.onap.portalapp.portal.domain.EPUser;
67 import org.onap.portalapp.portal.ecomp.model.PortalRestResponse;
68 import org.onap.portalapp.portal.ecomp.model.PortalRestStatusEnum;
69 import org.onap.portalapp.portal.framework.MockitoTestSuite;
70 import org.onap.portalapp.portal.service.ExternalAccessRolesService;
71 import org.onap.portalapp.portal.service.ExternalAccessRolesServiceImpl;
72 import org.onap.portalapp.portal.transport.CentralRole;
73 import org.onap.portalapp.portal.transport.CentralRoleFunction;
74 import org.onap.portalapp.portal.transport.CentralUser;
75 import org.onap.portalapp.portal.transport.CentralV2Role;
76 import org.onap.portalapp.portal.transport.ExternalRequestFieldsValidator;
77 import org.onap.portalapp.portal.utils.EPCommonSystemProperties;
78 import org.onap.portalapp.portal.utils.EcompPortalUtils;
79 import org.onap.portalapp.portal.utils.PortalConstants;
80 import org.onap.portalsdk.core.domain.AuditLog;
81 import org.onap.portalsdk.core.domain.Role;
82 import org.onap.portalsdk.core.domain.User;
83 import org.onap.portalsdk.core.restful.domain.EcompRole;
84 import org.onap.portalsdk.core.restful.domain.EcompUser;
85 import org.onap.portalsdk.core.service.AuditService;
86 import org.onap.portalsdk.core.service.UserService;
87 import org.onap.portalsdk.core.service.UserServiceCentalizedImpl;
88 import org.onap.portalsdk.core.util.SystemProperties;
89 import org.powermock.api.mockito.PowerMockito;
90 import org.powermock.core.classloader.annotations.PrepareForTest;
91 import org.powermock.modules.junit4.PowerMockRunner;
92 import org.springframework.http.HttpStatus;
93 import org.springframework.http.ResponseEntity;
94 import org.springframework.test.util.MatcherAssertionErrors;
95 import org.springframework.web.client.HttpClientErrorException;
97 import com.fasterxml.jackson.core.JsonProcessingException;
98 import com.fasterxml.jackson.databind.DeserializationFeature;
99 import com.fasterxml.jackson.databind.ObjectMapper;
101 @RunWith(PowerMockRunner.class)
102 @PrepareForTest({ EcompPortalUtils.class, PortalConstants.class, SystemProperties.class,
103 EPCommonSystemProperties.class })
104 public class ExternalAccessRolesControllerTest {
107 ExternalAccessRolesService externalAccessRolesService = new ExternalAccessRolesServiceImpl();
110 ExternalAccessRolesController externalAccessRolesController = new ExternalAccessRolesController();
112 UserService userservice = new UserServiceCentalizedImpl();
115 AuditService auditService;
118 public void setup() {
119 MockitoAnnotations.initMocks(this);
122 AuditLog auditLog = new AuditLog();
124 MockitoTestSuite mockitoTestSuite = new MockitoTestSuite();
126 HttpServletRequest mockedRequest = mockitoTestSuite.getMockedRequest();
127 HttpServletResponse mockedResponse = mockitoTestSuite.getMockedResponse();
128 NullPointerException nullPointerException = new NullPointerException();
129 HttpClientErrorException httpClientErrorException = new HttpClientErrorException(HttpStatus.BAD_REQUEST, "Failed");
131 MockEPUser mockUser = new MockEPUser();
132 String loginId = "guestT";
133 String uebKey = "testUebKey";
135 public EPApp mockApp()
137 EPApp app = new EPApp();
139 app.setImageUrl("test");
140 app.setDescription("test");
141 app.setNotes("test");
144 app.setAppRestEndpoint("test");
145 app.setAlternateUrl("test");
147 app.setMlAppName("test");
148 app.setMlAppAdminId("test");
149 app.setUsername("test");
150 app.setAppPassword("test");
152 app.setEnabled(false);
153 app.setUebKey("test");
154 app.setUebSecret("test");
155 app.setUebTopicName("test");
161 public void getUserTest() throws Exception {
162 CentralUser expectedCentralUser = new CentralUser(null, null, null, null, null, null, null, null, loginId, loginId, loginId, loginId, loginId, loginId, loginId, null, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, null, false, false, null, null, false, loginId, null);
163 String loginId = "test";
164 StringWriter sw = new StringWriter();
165 PrintWriter writer = new PrintWriter(sw);
166 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
167 EPApp app = mockApp();
168 app.setCentralAuth(true);
169 List<EPApp> appList = new ArrayList<>();
171 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
172 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
173 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
174 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
175 Mockito.when(externalAccessRolesService.getUserRoles(loginId, mockedRequest.getHeader("uebkey"))).thenReturn(expectedCentralUser);
176 CentralUser actualCentralUser = externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId);
177 assertEquals(actualCentralUser.isActive(), expectedCentralUser.isActive());
181 public void getUserExceptionTest() throws Exception {
182 String reason = getInvalidKeyJson();
183 StringWriter sw = new StringWriter();
184 PrintWriter writer = new PrintWriter(sw);
185 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
186 externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId);
187 String result = sw.getBuffer().toString().trim();
188 assertEquals(reason, result);
192 public void getV2UserListTest() throws Exception {
193 String expectedCentralUser = "test";
194 String loginId = "test";
195 EPApp app = mockApp();
196 app.setCentralAuth(true);
197 List<EPApp> appList = new ArrayList<>();
199 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
200 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
201 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
202 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
203 Mockito.when(externalAccessRolesService.getV2UserWithRoles(loginId, mockedRequest.getHeader("uebkey"))).thenReturn(expectedCentralUser);
204 String actualString = externalAccessRolesController.getV2UserList(mockedRequest, mockedResponse, loginId);
205 assertEquals(actualString, expectedCentralUser);
208 @Test(expected = NullPointerException.class)
209 public void getV2UserListExceptionTest() throws Exception {
210 String expectedCentralUser = null;
211 String loginId = "test";
212 EPApp app = mockApp();
213 app.setCentralAuth(true);
214 List<EPApp> appList = new ArrayList<>();
216 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
217 ResponseEntity<String> response = null;
218 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
219 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
220 Mockito.when(externalAccessRolesService.getV2UserWithRoles(loginId, mockedRequest.getHeader("uebkey"))).thenReturn(expectedCentralUser);
221 String actualString = externalAccessRolesController.getV2UserList(mockedRequest, mockedResponse, loginId);
222 assertEquals(actualString, expectedCentralUser);
226 public void getRolesForAppCentralRoleTest() throws Exception {
227 List<CentralRole> expectedCentralRoleList = new ArrayList<CentralRole>();
228 List<EPApp> applicationList = new ArrayList<EPApp>();
229 List<CentralV2Role> centralV2RoleList = new ArrayList<>();
230 List<CentralRole> centralRoleList = new ArrayList<>();
231 EPApp app = mockApp();
232 app.setCentralAuth(true);
233 applicationList.add(app);
234 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
235 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
236 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
237 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
238 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
239 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey))).thenReturn(centralV2RoleList);
240 Mockito.when(externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(centralV2RoleList)).thenReturn(centralRoleList);
241 List<CentralRole> actualCentralRoleList = externalAccessRolesController.getRolesForApp(mockedRequest, mockedResponse);
242 assertEquals(actualCentralRoleList.size(), expectedCentralRoleList.size());
245 @Test(expected = NullPointerException.class)
246 public void getRolesForAppCentralRoleExceptionTest() throws Exception {
247 List<EPApp> applicationList = new ArrayList<EPApp>();
248 List<CentralV2Role> centralV2RoleList = new ArrayList<>();
249 List<CentralRole> centralRoleList = new ArrayList<>();
250 EPApp app = mockApp();
251 app.setCentralAuth(true);
252 applicationList.add(app);
253 ResponseEntity<String> response = null;
254 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
255 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
256 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
257 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
258 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey))).thenReturn(centralV2RoleList);
259 Mockito.when(externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(centralV2RoleList)).thenReturn(centralRoleList);
260 List<CentralRole> actualCentralRoleList = externalAccessRolesController.getRolesForApp(mockedRequest, mockedResponse);
261 assertEquals(null,actualCentralRoleList);
265 public void getV2RolesForAppTest() throws Exception {
266 List<CentralRole> expectedCentralRoleList = new ArrayList<CentralRole>();
267 List<EPApp> applicationList = new ArrayList<EPApp>();
268 List<CentralV2Role> centralV2Role = new ArrayList<>();
269 EPApp app = mockApp();
270 app.setCentralAuth(true);
271 applicationList.add(app);
272 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
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))).thenReturn(centralV2Role);
278 List<CentralV2Role> actualCentralV2Role = externalAccessRolesController.getV2RolesForApp(mockedRequest, mockedResponse);
279 assertEquals(actualCentralV2Role.size(), expectedCentralRoleList.size());
282 @Test(expected = NullPointerException.class)
283 public void getV2RolesForAppExceptionTest() throws Exception {
284 List<CentralRole> expectedCentralRoleList = new ArrayList<CentralRole>();
285 List<EPApp> applicationList = new ArrayList<EPApp>();
286 List<CentralV2Role> centralV2Role = new ArrayList<>();
287 EPApp app = mockApp();
288 app.setCentralAuth(true);
289 applicationList.add(app);
290 ResponseEntity<String> response = null;
291 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
292 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
293 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
294 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
295 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey))).thenReturn(centralV2Role);
296 List<CentralV2Role> actualCentralV2Role = externalAccessRolesController.getV2RolesForApp(mockedRequest, mockedResponse);
297 assertEquals(actualCentralV2Role.size(), expectedCentralRoleList.size());
300 @Test(expected = NullPointerException.class)
301 public void getRolesForAppTest() throws Exception {
302 List<EPApp> applicationList = new ArrayList<EPApp>();
303 List<CentralV2Role> answer = new ArrayList<>();
304 EPApp app = mockApp();
305 applicationList.add(app);
306 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
307 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
308 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey))).thenReturn(answer);
309 assertEquals(externalAccessRolesController.getRolesForApp(mockedRequest, mockedResponse), null);
312 @Test(expected = NullPointerException.class)
313 public void getRolesForAppExceptionTest() throws Exception {
314 List<EPApp> applicationList = new ArrayList<EPApp>();
315 EPApp app = mockApp();
316 applicationList.add(app);
317 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
318 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
319 externalAccessRolesController.getRolesForApp(mockedRequest,mockedResponse);
320 List<CentralV2Role> role = externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey));
321 assertEquals(null,role);
325 public void getRoleFunctionsListTest() throws Exception {
326 List<CentralRole> expectedCentralRoleList = new ArrayList<CentralRole>();
327 List<CentralRoleFunction> roleFuncList = new ArrayList<CentralRoleFunction>();
328 List<EPApp> applicationList = new ArrayList<EPApp>();
329 List<CentralV2RoleFunction> centralV2RoleFunction = new ArrayList<>();
330 EPApp app = mockApp();
331 app.setCentralAuth(true);
332 applicationList.add(app);
333 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
334 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
335 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
336 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
337 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
338 Mockito.when(externalAccessRolesService.getRoleFuncList(mockedRequest.getHeader("uebkey"))).thenReturn(centralV2RoleFunction);
339 Mockito.when(externalAccessRolesService.convertCentralRoleFunctionToRoleFunctionObject(centralV2RoleFunction)).thenReturn(roleFuncList);
340 List<CentralRoleFunction> actualCentralRoleFunction = externalAccessRolesController.getRoleFunctionsList(mockedRequest, mockedResponse);
341 assertEquals(actualCentralRoleFunction.size(), expectedCentralRoleList.size());
345 public void getRoleFunctionsListExceptionTest() throws Exception {
346 String reason = getInvalidKeyJson();
347 StringWriter sw = new StringWriter();
348 PrintWriter writer = new PrintWriter(sw);
349 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
350 externalAccessRolesController.getRoleFunctionsList(mockedRequest, mockedResponse);
351 String result = sw.getBuffer().toString().trim();
352 assertEquals(reason, result);
356 public void getV2RoleFunctionsListTest() throws Exception {
357 List<CentralV2RoleFunction> expectedCentralV2RoleFunctionList = new ArrayList<CentralV2RoleFunction>();
358 List<EPApp> applicationList = new ArrayList<EPApp>();
359 List<CentralV2RoleFunction> centralV2RoleFunction = new ArrayList<>();
360 EPApp app = mockApp();
361 app.setCentralAuth(true);
362 applicationList.add(app);
363 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
364 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
365 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
366 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
367 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
368 Mockito.when(externalAccessRolesService.getRoleFuncList(mockedRequest.getHeader("uebkey"))).thenReturn(centralV2RoleFunction);
369 List<CentralV2RoleFunction> actualCentralV2RoleFunctionList = externalAccessRolesController.getV2RoleFunctionsList(mockedRequest, mockedResponse);
370 assertEquals(actualCentralV2RoleFunctionList.size(), expectedCentralV2RoleFunctionList.size());
374 public void getV2RoleFunctionsListExceptionTest() 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.getV2RoleFunctionsList(mockedRequest, mockedResponse);
380 String result = sw.getBuffer().toString().trim();
381 assertEquals(reason, result);
385 public void getRoleInfoValidationTest() throws Exception {
386 CentralRole expectedCentralRole = null;
387 List<EPApp> applicationList = new ArrayList<EPApp>();
389 CentralV2Role centralV2Role = new CentralV2Role();
390 EPApp app = mockApp();
391 app.setCentralAuth(true);
392 applicationList.add(app);
393 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
394 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
395 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
396 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
397 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader("uebkey"))).thenReturn(centralV2Role);
398 CentralRole actualCentralRole = externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse, roleId);
399 assertEquals(actualCentralRole, expectedCentralRole);
403 public void getRoleInfoTest() throws Exception {
404 String reason = getInvalidKeyJson();
405 StringWriter sw = new StringWriter();
406 PrintWriter writer = new PrintWriter(sw);
407 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
408 CentralV2Role answer = new CentralV2Role();
410 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader(uebKey)))
412 externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse, roleId);
413 String result = sw.getBuffer().toString().trim();
414 assertEquals(reason, result);
418 public void getRoleInfoExceptionTest() throws Exception {
419 String reason = getInvalidKeyJson();
420 StringWriter sw = new StringWriter();
421 PrintWriter writer = new PrintWriter(sw);
422 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
424 assertNull(externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse, roleId));
425 String result = sw.getBuffer().toString().trim();
426 assertEquals(reason, result);
430 public void getV2RoleInfoValidationTest() throws Exception {
431 CentralV2Role expectedCentralRole = new CentralV2Role();
432 expectedCentralRole.setActive(false);
433 List<EPApp> applicationList = new ArrayList<EPApp>();
435 CentralV2Role centralV2Role = new CentralV2Role();
436 EPApp app = mockApp();
437 app.setCentralAuth(true);
438 applicationList.add(app);
439 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
440 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
441 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
442 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
443 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader("uebkey"))).thenReturn(centralV2Role);
444 CentralV2Role actualCentralRole = externalAccessRolesController.getV2RoleInfo(mockedRequest, mockedResponse, roleId);
445 assertEquals(actualCentralRole.getActive(), expectedCentralRole.getActive());
449 public void getV2RoleInfoTest() throws Exception {
450 String reason = getInvalidKeyJson();
451 StringWriter sw = new StringWriter();
452 PrintWriter writer = new PrintWriter(sw);
453 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
454 CentralV2Role answer = new CentralV2Role();
456 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader(uebKey)))
458 externalAccessRolesController.getV2RoleInfo(mockedRequest, mockedResponse, roleId);
459 String result = sw.getBuffer().toString().trim();
460 assertEquals(reason, result);
464 public void getV2RoleInfoExceptionTest() throws Exception {
465 String reason = getInvalidKeyJson();
466 StringWriter sw = new StringWriter();
467 PrintWriter writer = new PrintWriter(sw);
468 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
470 assertNull(externalAccessRolesController.getV2RoleInfo(mockedRequest, mockedResponse, roleId));
471 String result = sw.getBuffer().toString().trim();
472 assertEquals(reason, result);
476 public void getV2RoleFunctionTest() throws HttpClientErrorException, Exception{
477 CentralV2RoleFunction expectedCentralV2RoleFunction = new CentralV2RoleFunction();
478 expectedCentralV2RoleFunction.setCode("test");
479 List<EPApp> applicationList = new ArrayList<EPApp>();
480 String code = "test";
481 CentralV2RoleFunction centralV2RoleFunction = new CentralV2RoleFunction();
482 centralV2RoleFunction.setCode("test");
483 EPApp app = mockApp();
484 app.setCentralAuth(true);
485 applicationList.add(app);
486 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
487 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
488 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
489 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
490 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader("uebkey"))).thenReturn(centralV2RoleFunction);
491 CentralV2RoleFunction actualCentralV2RoleFunction = externalAccessRolesController.getV2RoleFunction(mockedRequest, mockedResponse, code);
492 assertEquals(actualCentralV2RoleFunction.getCode(), expectedCentralV2RoleFunction.getCode());
496 public void getV2RoleFunctionNullCheckTest() throws HttpClientErrorException, Exception{
497 CentralV2RoleFunction expectedCentralV2RoleFunction = new CentralV2RoleFunction();
498 List<EPApp> applicationList = new ArrayList<EPApp>();
499 String code = "test";
500 CentralV2RoleFunction centralV2RoleFunction = null;
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"))).thenReturn(centralV2RoleFunction);
509 CentralV2RoleFunction actualCentralV2RoleFunction = externalAccessRolesController.getV2RoleFunction(mockedRequest, mockedResponse, code);
510 assertEquals(actualCentralV2RoleFunction.getAction(), expectedCentralV2RoleFunction.getAction());
514 public void getV2RoleFunctionExceptionTest() throws Exception {
515 String reason = getInvalidKeyJson();
516 StringWriter sw = new StringWriter();
517 PrintWriter writer = new PrintWriter(sw);
518 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
519 String code = "test";
520 assertNull(externalAccessRolesController.getV2RoleFunction(mockedRequest, mockedResponse, code));
521 String result = sw.getBuffer().toString().trim();
522 assertEquals(reason, result);
526 public void getRoleFunctionTest() throws Exception {
527 EPApp mockApp = mockApp();
528 mockApp.setCentralAuth(true);
529 List<EPApp> mockAppList = new ArrayList<>();
530 mockAppList.add(mockApp);
531 StringWriter sw = new StringWriter();
532 PrintWriter writer = new PrintWriter(sw);
533 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
534 CentralV2RoleFunction roleFunction1 = new CentralV2RoleFunction();
535 CentralRoleFunction roleFunction2 = new CentralRoleFunction();
536 roleFunction1.setCode("test2");
537 String code = "test_menu";
538 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
539 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(mockAppList);
540 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
541 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(mockAppList.get(0))).thenReturn(response);
542 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader("uebkey")))
543 .thenReturn(roleFunction1);
544 CentralRoleFunction returnedValue = externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse, code);
545 assertEquals(returnedValue, roleFunction2);
546 String result = sw.getBuffer().toString().trim();
547 assertEquals("", result);
551 public void getRoleFunctionExceptionTest() throws Exception {
552 String reason = getInvalidKeyJson();
553 StringWriter sw = new StringWriter();
554 PrintWriter writer = new PrintWriter(sw);
555 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
556 String code = "test_menu";
557 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader(uebKey)))
558 .thenThrow(httpClientErrorException);
559 assertEquals(new CentralRoleFunction(),externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse, code));
560 String result = sw.getBuffer().toString().trim();
561 assertEquals(reason, result);
565 public void saveRoleFunctionIfIsNotDeletedTest() throws Exception {
566 List<EPApp> applicationList = new ArrayList<EPApp>();
567 EPApp app = mockApp();
568 applicationList.add(app);
569 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
570 PortalRestResponse<String> portalRestResponse = null;
571 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
572 expectedportalRestResponse.setMessage(null);
573 expectedportalRestResponse.setResponse("Failed");
574 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
576 CentralV2RoleFunction centralV2RoleFunction = new CentralV2RoleFunction();
577 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
578 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
579 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
580 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
581 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(centralV2RoleFunction, app)).thenReturn(false);
582 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, data);
583 assertEquals(portalRestResponse, expectedportalRestResponse);
587 public void saveRoleFunctionExceptionTest() throws Exception {
588 List<EPApp> applicationList = new ArrayList<EPApp>();
589 EPApp app = mockApp();
590 app.setCentralAuth(true);
591 applicationList.add(app);
592 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
593 PortalRestResponse<String> portalRestResponse = null;
594 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
595 expectedportalRestResponse.setMessage(null);
596 expectedportalRestResponse.setResponse("Failed");
597 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
598 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
599 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
600 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
601 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
602 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, null);
603 assertEquals(portalRestResponse, expectedportalRestResponse);
607 public void saveRoleFunctionTest() throws Exception {
608 List<EPApp> applicationList = new ArrayList<EPApp>();
609 EPUser user = mockUser.mockEPUser();
610 List<EPUser> userList = new ArrayList<>();
612 EPApp app = mockApp();
613 app.setCentralAuth(true);
614 applicationList.add(app);
615 JSONObject roleFunc = new JSONObject();
616 roleFunc.put("type", "test_type");
617 roleFunc.put("code", "test_instance");
618 roleFunc.put("action", "test_action");
619 roleFunc.put("name", "test_name");
620 ObjectMapper mapper = new ObjectMapper();
621 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
622 CentralV2RoleFunction saveRoleFunc = mapper.readValue(roleFunc.toString(), CentralV2RoleFunction.class);
623 saveRoleFunc.setAppId(app.getId());
624 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
625 PortalRestResponse<String> portalRestResponse = null;
626 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
627 expectedportalRestResponse.setMessage("Successfully saved!");
628 expectedportalRestResponse.setResponse("Success");
629 PortalRestStatusEnum portalRestStatusEnum = null;
630 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
631 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
632 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
633 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
634 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
635 Mockito.when(externalAccessRolesService.getRoleFunction("test_type|test_instance|test_action", app.getUebKey()))
637 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(Matchers.any(CentralV2RoleFunction.class),
638 Matchers.any(EPApp.class))).thenReturn(true);
639 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader(Matchers.anyString())))
640 .thenReturn(userList);
641 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(Matchers.anyString())))
642 .thenReturn(applicationList);
643 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse,
644 roleFunc.toString());
645 assertEquals(portalRestResponse, expectedportalRestResponse);
649 public void deleteRoleFunctionTest() throws Exception {
650 PowerMockito.mockStatic(EcompPortalUtils.class);
651 PowerMockito.mockStatic(SystemProperties.class);
652 PowerMockito.mockStatic(EPCommonSystemProperties.class);
653 PowerMockito.mockStatic(PortalConstants.class);
654 PortalRestResponse<String> portalRestResponse = null;
655 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
656 expectedportalRestResponse.setMessage("Successfully Deleted");
657 expectedportalRestResponse.setResponse("Success");
658 PortalRestStatusEnum portalRestStatusEnum = null;
659 EPUser user = mockUser.mockEPUser();
660 List<EPUser> userList = new ArrayList<>();
662 EPApp app = mockApp();
663 app.setCentralAuth(true);
664 List<EPApp> appList = new ArrayList<>();
666 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
667 String code ="testNew";
668 Mockito.when(mockedRequest.getHeader("LoginId")).thenReturn("guestT");
669 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
670 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
671 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
672 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
673 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
674 Mockito.when(externalAccessRolesService.deleteCentralRoleFunction(code, app)).thenReturn(true);
675 portalRestResponse = externalAccessRolesController.deleteRoleFunction(mockedRequest, mockedResponse, code);
676 assertEquals(portalRestResponse, expectedportalRestResponse);
680 public void getActiveRolesTest() throws Exception {
681 String reason = getInvalidKeyJson();
682 StringWriter sw = new StringWriter();
683 PrintWriter writer = new PrintWriter(sw);
684 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
685 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey))).thenReturn(null);
686 List<CentralRole> expectedCenRole = externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
687 assertNull(expectedCenRole);
688 String result = sw.getBuffer().toString().trim();
689 assertEquals(reason, result);
693 public void getActiveRolesValidationTest() throws Exception {
694 List<CentralRole> expectedRolesList = null;
695 EPApp app = mockApp();
696 app.setCentralAuth(true);
697 List<EPApp> appList = new ArrayList<EPApp>();
699 List<CentralV2Role> cenRoles = new ArrayList<CentralV2Role>();
700 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
701 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
702 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
703 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
704 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader("uebkey"))).thenReturn(cenRoles);
705 Mockito.when(externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(cenRoles)).thenReturn(expectedRolesList);
706 List<CentralRole> actualRolesList = externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
707 assertEquals(actualRolesList, expectedRolesList);
711 public void getActiveRolesExceptionTest() throws Exception {
712 String reason = getInvalidKeyJson();
713 StringWriter sw = new StringWriter();
714 PrintWriter writer = new PrintWriter(sw);
715 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
716 externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
717 String result = sw.getBuffer().toString().trim();
718 assertEquals(reason, result);
722 * It return JSON string which has error information
724 * @return JSON String
725 * @throws JsonProcessingException
727 private String getInvalidKeyJson() throws JsonProcessingException {
728 final Map<String,String> uebkeyResponse = new HashMap<>();
730 ObjectMapper mapper = new ObjectMapper();
731 uebkeyResponse.put("error","Invalid uebkey!");
732 reason = mapper.writeValueAsString(uebkeyResponse);
737 public void deleteDependcyRoleRecordExceptionTest() throws Exception {
738 PortalRestResponse<String> portalRestResponse = null;
739 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
740 expectedportalRestResponse.setMessage("Invalid uebkey!");
741 expectedportalRestResponse.setResponse("Failed");
742 PortalRestStatusEnum portalRestStatusEnum = null;
743 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
745 portalRestResponse = externalAccessRolesController.deleteDependencyRoleRecord(mockedRequest, mockedResponse, roleId);
746 assertEquals(expectedportalRestResponse, portalRestResponse);
750 public void bulkUploadFunctionsTest() throws Exception {
752 Mockito.when(externalAccessRolesService.bulkUploadFunctions(mockedRequest.getHeader(uebKey)))
754 PortalRestResponse<String> portalRestResponse = null;
755 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
756 expectedportalRestResponse.setMessage("Successfully added: 0");
757 expectedportalRestResponse.setResponse("Success");
758 PortalRestStatusEnum portalRestStatusEnum = null;
759 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
760 portalRestResponse = externalAccessRolesController.bulkUploadFunctions(mockedRequest, mockedResponse);
761 assertEquals(portalRestResponse, expectedportalRestResponse);
765 public void bulkUploadFunctionsExceptionTest() throws Exception {
766 Mockito.when(externalAccessRolesService.bulkUploadFunctions(mockedRequest.getHeader(uebKey)))
767 .thenThrow(httpClientErrorException);
768 PortalRestResponse<String> portalRestResponse = null;
769 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
770 expectedportalRestResponse.setMessage("Failed to bulkUploadFunctions");
771 expectedportalRestResponse.setResponse("Failed");
772 PortalRestStatusEnum portalRestStatusEnum = null;
773 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
774 portalRestResponse = externalAccessRolesController.bulkUploadFunctions(mockedRequest, mockedResponse);
775 assertEquals(portalRestResponse, expectedportalRestResponse);
779 public void bulkUploadRolesTest() throws Exception {
781 PortalRestResponse<String> portalRestResponse = null;
782 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
783 expectedportalRestResponse.setMessage("Successfully added: 0");
784 expectedportalRestResponse.setResponse("Success");
785 PortalRestStatusEnum portalRestStatusEnum = null;
786 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
787 Mockito.when(externalAccessRolesService.bulkUploadRoles(mockedRequest.getHeader(uebKey))).thenReturn(result);
788 portalRestResponse = externalAccessRolesController.bulkUploadRoles(mockedRequest, mockedResponse);
789 assertEquals(portalRestResponse, expectedportalRestResponse);
793 public void bulkUploadRolesTestException() throws Exception {
794 Mockito.when(externalAccessRolesService.bulkUploadRoles(mockedRequest.getHeader(uebKey)))
795 .thenThrow(httpClientErrorException);
796 PortalRestResponse<String> portalRestResponse = null;
797 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
798 expectedportalRestResponse.setMessage("Failed to bulkUploadRoles");
799 expectedportalRestResponse.setResponse("Failed");
800 PortalRestStatusEnum portalRestStatusEnum = null;
801 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
802 portalRestResponse = externalAccessRolesController.bulkUploadRoles(mockedRequest, mockedResponse);
803 assertEquals(portalRestResponse, expectedportalRestResponse);
807 public void bulkUploadRoleFunctionsTest() throws Exception {
809 PortalRestResponse<String> portalRestResponse = null;
810 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
811 expectedportalRestResponse.setMessage("Successfully added: 0");
812 expectedportalRestResponse.setResponse("Success");
813 PortalRestStatusEnum portalRestStatusEnum = null;
814 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
815 Mockito.when(externalAccessRolesService.bulkUploadRolesFunctions(mockedRequest.getHeader(uebKey)))
817 portalRestResponse = externalAccessRolesController.bulkUploadRoleFunctions(mockedRequest, mockedResponse);
818 assertEquals(portalRestResponse, expectedportalRestResponse);
822 public void bulkUploadRoleFunctionsException() throws Exception {
823 Mockito.when(externalAccessRolesService.bulkUploadRolesFunctions(mockedRequest.getHeader(uebKey)))
824 .thenThrow(httpClientErrorException);
825 PortalRestResponse<String> portalRestResponse = null;
826 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
827 expectedportalRestResponse.setMessage("Failed to bulkUploadRoleFunctions");
828 expectedportalRestResponse.setResponse("Failed");
829 PortalRestStatusEnum portalRestStatusEnum = null;
830 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
831 portalRestResponse = externalAccessRolesController.bulkUploadRoleFunctions(mockedRequest, mockedResponse);
832 assertEquals(portalRestResponse, expectedportalRestResponse);
836 public void bulkUploadUserRolesTest() throws Exception {
838 PortalRestResponse<String> portalRestResponse = null;
839 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
840 expectedportalRestResponse.setMessage("Successfully added: 0");
841 expectedportalRestResponse.setResponse("Success");
842 PortalRestStatusEnum portalRestStatusEnum = null;
843 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
844 Mockito.when(externalAccessRolesService.bulkUploadUserRoles(mockedRequest.getHeader(uebKey)))
846 portalRestResponse = externalAccessRolesController.bulkUploadUserRoles(mockedRequest, mockedResponse);
847 assertEquals(portalRestResponse, expectedportalRestResponse);
851 public void bulkUploadUserRolesExceptionTest() throws Exception {
852 Mockito.when(externalAccessRolesService.bulkUploadUserRoles(mockedRequest.getHeader(uebKey)))
853 .thenThrow(httpClientErrorException);
854 PortalRestResponse<String> portalRestResponse = null;
855 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
856 expectedportalRestResponse.setMessage("Failed to bulkUploadUserRoles");
857 expectedportalRestResponse.setResponse("Failed");
858 PortalRestStatusEnum portalRestStatusEnum = null;
859 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
860 portalRestResponse = externalAccessRolesController.bulkUploadUserRoles(mockedRequest, mockedResponse);
861 assertEquals(portalRestResponse, expectedportalRestResponse);
865 public void bulkUploadPartnerFunctionsTest() throws Exception {
866 PortalRestResponse<String> portalRestResponse = null;
867 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
868 expectedportalRestResponse.setMessage("Successfully added: '0' functions");
869 expectedportalRestResponse.setResponse("Success");
870 PortalRestStatusEnum portalRestStatusEnum = null;
871 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
872 portalRestResponse = externalAccessRolesController.bulkUploadPartnerFunctions(mockedRequest, mockedResponse);
873 assertEquals(portalRestResponse, expectedportalRestResponse);
878 public void bulkUploadPartnerRolesTest() throws Exception {
879 PortalRestResponse<String> portalRestResponse = null;
880 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
881 expectedportalRestResponse.setMessage("Successfully added");
882 expectedportalRestResponse.setResponse("Success");
883 PortalRestStatusEnum portalRestStatusEnum = null;
884 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
885 List<Role> upload = new ArrayList<>();
886 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoles(mockedRequest, mockedResponse,
888 assertEquals(portalRestResponse, expectedportalRestResponse);
892 public void bulkUploadPartnerRolesExceptionTest() throws Exception
894 ExternalAccessRolesService externalAccessRolesService = null;
895 PortalRestResponse<String> portalRestResponse = null;
896 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
897 expectedportalRestResponse.setMessage("Successfully added");
898 expectedportalRestResponse.setResponse("Success");
899 PortalRestStatusEnum portalRestStatusEnum = null;
900 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
901 List<Role> upload = new ArrayList<>();
902 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoles(mockedRequest, mockedResponse,
904 assertEquals(portalRestResponse, expectedportalRestResponse);
908 public void getMenuFunctionsTest() throws Exception {
909 String reason = getInvalidKeyJson();
910 StringWriter sw = new StringWriter();
911 PrintWriter writer = new PrintWriter(sw);
912 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
913 Mockito.when(externalAccessRolesService.getMenuFunctionsList(mockedRequest.getHeader(uebKey)))
915 List<String> expectedFunctionsList = externalAccessRolesController.getMenuFunctions(mockedRequest,
917 assertNull(expectedFunctionsList);
918 String result = sw.getBuffer().toString().trim();
919 assertEquals(reason, result);
923 public void getMenuFunctionsExceptionTest() throws Exception {
924 String reason = getInvalidKeyJson();
925 StringWriter sw = new StringWriter();
926 PrintWriter writer = new PrintWriter(sw);
927 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
928 Mockito.when(externalAccessRolesService.getMenuFunctionsList(mockedRequest.getHeader(uebKey)))
929 .thenThrow(httpClientErrorException);
930 assertNull(externalAccessRolesController.getMenuFunctions(mockedRequest, mockedResponse));
931 String result = sw.getBuffer().toString().trim();
932 assertEquals(reason, result);
937 public void saveRoleExceptionTest() throws Exception {
938 Role role = new Role();
939 PortalRestResponse<String> portalRestResponse = null;
940 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
941 expectedportalRestResponse.setMessage("Invalid uebkey!");
942 expectedportalRestResponse.setResponse("Failed");
943 PortalRestStatusEnum portalRestStatusEnum = null;
944 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
945 List<Role> upload = new ArrayList<>();
946 portalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse,role);
948 assertEquals(portalRestResponse, expectedportalRestResponse);
952 public void deleteRoleExceptionTest() throws Exception {
953 String role = "TestNew";
954 PortalRestResponse<String> portalRestResponse = null;
955 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
956 expectedportalRestResponse.setMessage("Invalid uebkey!");
957 expectedportalRestResponse.setResponse("Failed");
958 PortalRestStatusEnum portalRestStatusEnum = null;
959 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
960 portalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse,role);
961 assertEquals(portalRestResponse, expectedportalRestResponse);
966 public void bulkUploadPartnerRoleFunctionsTest() throws Exception {
967 PortalRestResponse<String> portalRestResponse = null;
968 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
969 expectedportalRestResponse.setMessage("Successfully added: '0' role functions");
970 expectedportalRestResponse.setResponse("Success");
971 PortalRestStatusEnum portalRestStatusEnum = null;
972 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
973 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoleFunctions(mockedRequest, mockedResponse);
974 assertEquals(portalRestResponse, expectedportalRestResponse);
978 public void getUsersOfApplicationTest() throws Exception
980 List<EcompUser> users = new ArrayList<>();
981 EcompUser user = new EcompUser();
982 user.setOrgUserId("guestT");
984 StringWriter sw = new StringWriter();
985 PrintWriter writer = new PrintWriter(sw);
986 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
987 List<EPApp> applicationList = new ArrayList<EPApp>();
988 EPApp app = mockApp();
989 app.setCentralAuth(true);
990 applicationList.add(app);
991 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
992 Mockito.when(externalAccessRolesService.getAllAppUsers(mockedRequest.getHeader(uebKey))).thenReturn(users);
993 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
994 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
995 List<EcompUser> expectedUsers = externalAccessRolesController.getUsersOfApplication(mockedRequest, mockedResponse);
996 assertEquals(expectedUsers, users);
999 @Test(expected = Exception.class)
1000 public void getUsersOfApplicationExceptionTest() throws Exception
1002 List<EcompUser> users = new ArrayList<>();
1003 EcompUser user = new EcompUser();
1004 user.setOrgUserId("guestT");
1006 Mockito.when(externalAccessRolesService.getAllAppUsers(mockedRequest.getHeader(uebKey))).thenThrow(nullPointerException);
1007 assertNull(externalAccessRolesController.getUsersOfApplication(mockedRequest, mockedResponse));
1010 @Test(expected = NullPointerException.class)
1011 public void deleteRoleV2Test() throws Exception
1013 List<EPApp> applicationList = new ArrayList<EPApp>();
1014 EPApp app = mockApp();
1015 applicationList.add(app);
1016 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1017 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(true, "Success");
1018 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(),Matchers.anyString(),Matchers.anyString())).thenReturn(externalRequestFieldsValidator);
1019 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
1020 expectedportalRestResponse.setMessage("Successfully Deleted");
1021 expectedportalRestResponse.setResponse("Success");
1022 PortalRestStatusEnum portalRestStatusEnum = null;
1023 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
1024 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, (long)1);
1025 assertNull(actualResponse);
1029 public void deleteRoleV2InvalidUebKeyTest() throws Exception
1031 List<EPApp> applicationList = new ArrayList<EPApp>();
1032 EPApp app = mockApp();
1033 applicationList.add(app);
1034 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenThrow(new Exception("Invalid uebkey!"));
1035 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
1036 expectedportalRestResponse.setMessage("Invalid uebkey!");
1037 expectedportalRestResponse.setResponse("Failed");
1038 PortalRestStatusEnum portalRestStatusEnum = null;
1039 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
1040 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, (long)1);
1041 assertEquals(actualResponse, expectedportalRestResponse);
1045 public void deleteRoleV2InvalidUebKeyWithDiffErrorTest() throws Exception
1047 List<EPApp> applicationList = new ArrayList<EPApp>();
1048 EPApp app = mockApp();
1049 applicationList.add(app);
1050 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenThrow(new Exception("test"));
1051 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
1052 expectedportalRestResponse.setMessage("test");
1053 expectedportalRestResponse.setResponse("Failed");
1054 PortalRestStatusEnum portalRestStatusEnum = null;
1055 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
1056 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, (long)1);
1057 assertEquals(actualResponse, expectedportalRestResponse);
1061 @Test(expected = NullPointerException.class)
1062 public void deleteRoleV2ExceptionTest() throws Exception
1064 List<EPApp> applicationList = new ArrayList<EPApp>();
1065 EPApp app = mockApp();
1066 applicationList.add(app);
1067 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1068 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false, "failed");
1069 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(),Matchers.anyString(),Matchers.anyString())).thenReturn(externalRequestFieldsValidator);
1070 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
1071 expectedportalRestResponse.setMessage("Failed to deleteRole");
1072 expectedportalRestResponse.setResponse("Failed");
1073 PortalRestStatusEnum portalRestStatusEnum = null;
1074 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
1075 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, (long)1);
1076 assertEquals(actualResponse, null);
1080 public void getEpUserNullTest() throws Exception{
1081 List<EPApp> applicationList = new ArrayList<EPApp>();
1082 EPApp app = mockApp();
1083 app.setUebKey("uebKey");
1084 app.setCentralAuth(true);
1085 applicationList.add(app);
1086 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1087 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
1088 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
1089 assertNull(externalAccessRolesController.getEcompUser(mockedRequest, mockedResponse, "test12"));
1093 public void getEpUserTest() throws Exception{
1094 List<EPApp> applicationList = new ArrayList<EPApp>();
1095 EPApp app = mockApp();
1096 app.setUebKey("uebKey");
1097 app.setCentralAuth(true);
1098 applicationList.add(app);
1099 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1100 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
1101 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
1102 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\"}";
1103 Mockito.when(externalAccessRolesService.getV2UserWithRoles("test12", mockedRequest.getHeader(uebKey))).thenReturn(user);
1104 User EPuser = new User();
1105 EPuser.setFirstName("test");
1106 Mockito.when(userservice.userMapper(user)).thenReturn(EPuser);
1107 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\":[]}";
1108 assertEquals(externalAccessRolesController.getEcompUser(mockedRequest, mockedResponse, "test12"),res);
1112 public void getEpUserExceptionTest() throws Exception{
1113 List<EPApp> applicationList = new ArrayList<EPApp>();
1114 EPApp app = mockApp();
1115 app.setCentralAuth(true);
1116 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1117 StringWriter sw = new StringWriter();
1118 PrintWriter writer = new PrintWriter(sw);
1119 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
1120 assertNull(externalAccessRolesController.getEcompUser(mockedRequest, mockedResponse, "test12"));
1124 public void getEPRolesOfApplicationTest() throws Exception
1126 List<EPApp> applicationList = new ArrayList<EPApp>();
1127 EPApp app = mockApp();
1128 app.setUebKey("uebKey");
1129 app.setCentralAuth(true);
1130 applicationList.add(app);
1131 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1132 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
1133 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
1134 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
1135 List<CentralV2Role> cenRoleList = new ArrayList<>();
1136 CentralV2Role role = new CentralV2Role();
1137 role.setName("test");
1138 cenRoleList.add(role);
1139 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey))).thenReturn(cenRoleList);
1140 List<EcompRole> ecompRoles = new ArrayList<>();
1141 EcompRole eprole = new EcompRole();
1142 eprole.setName("test");
1143 ecompRoles.add(eprole);
1144 assertEquals(ecompRoles,externalAccessRolesController.getEcompRolesOfApplication(mockedRequest, mockedResponse));
1147 public void getEPRolesOfApplicationNullTest() throws Exception
1149 List<EPApp> applicationList = new ArrayList<EPApp>();
1150 EPApp app = mockApp();
1151 app.setUebKey("uebKey");
1152 app.setCentralAuth(true);
1153 applicationList.add(app);
1154 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1155 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
1156 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
1157 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
1158 List<CentralV2Role> cenRoleList = new ArrayList<>();
1159 CentralV2Role role = new CentralV2Role();
1160 role.setName("test");
1161 cenRoleList.add(role);
1162 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey))).thenReturn(null);
1163 assertNull(externalAccessRolesController.getEcompRolesOfApplication(mockedRequest, mockedResponse));
1168 public void getEPRolesOfApplicationExceptionTest() throws Exception
1170 List<EPApp> applicationList = new ArrayList<EPApp>();
1171 EPApp app = mockApp();
1172 app.setCentralAuth(true);
1173 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1174 StringWriter sw = new StringWriter();
1175 PrintWriter writer = new PrintWriter(sw);
1176 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
1177 assertNull(externalAccessRolesController.getEcompRolesOfApplication(mockedRequest, mockedResponse));
1182 public void saveRoleTest() throws Exception{
1183 PowerMockito.mockStatic(EcompPortalUtils.class);
1184 PowerMockito.mockStatic(SystemProperties.class);
1185 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1186 PowerMockito.mockStatic(PortalConstants.class);
1187 PortalRestResponse<String> actualPortalRestResponse = null;
1188 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
1189 expectedportalRestResponse.setMessage("Successfully Saved");
1190 expectedportalRestResponse.setResponse("Success");
1191 PortalRestStatusEnum portalRestStatusEnum = null;
1192 EPUser user = mockUser.mockEPUser();
1193 List<EPUser> userList = new ArrayList<>();
1195 EPApp app = mockApp();
1196 app.setCentralAuth(true);
1197 List<EPApp> appList = new ArrayList<>();
1199 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
1200 Role role = new Role();
1201 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(true, "Success");
1202 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1203 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1204 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1205 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1206 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1207 Mockito.when(externalAccessRolesService.saveRoleForApplication(role, mockedRequest.getHeader("uebkey"))).thenReturn(externalRequestFieldsValidator);
1208 actualPortalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse, role);
1209 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1213 public void saveRoleNegativeTest() throws Exception{
1214 PowerMockito.mockStatic(EcompPortalUtils.class);
1215 PowerMockito.mockStatic(SystemProperties.class);
1216 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1217 PowerMockito.mockStatic(PortalConstants.class);
1218 PortalRestResponse<String> actualPortalRestResponse = null;
1219 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
1220 expectedportalRestResponse.setMessage("Successfully Saved");
1221 expectedportalRestResponse.setResponse("Success");
1222 PortalRestStatusEnum portalRestStatusEnum = null;
1223 EPUser user = mockUser.mockEPUser();
1224 List<EPUser> userList = new ArrayList<>();
1226 EPApp app = mockApp();
1227 app.setCentralAuth(true);
1228 List<EPApp> appList = new ArrayList<>();
1230 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
1231 Role role = new Role();
1232 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false, "Failed");
1233 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1234 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1235 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1236 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1237 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1238 Mockito.when(externalAccessRolesService.saveRoleForApplication(role, mockedRequest.getHeader("uebkey"))).thenReturn(externalRequestFieldsValidator);
1239 actualPortalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse, role);
1240 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1244 public void saveRole406Test() throws Exception{
1245 PowerMockito.mockStatic(EcompPortalUtils.class);
1246 PowerMockito.mockStatic(SystemProperties.class);
1247 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1248 PowerMockito.mockStatic(PortalConstants.class);
1249 PortalRestResponse<String> actualPortalRestResponse = null;
1250 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
1251 expectedportalRestResponse.setMessage("Successfully Saved");
1252 expectedportalRestResponse.setResponse("Failed");
1253 PortalRestStatusEnum portalRestStatusEnum = null;
1254 EPUser user = mockUser.mockEPUser();
1255 List<EPUser> userList = new ArrayList<>();
1257 EPApp app = mockApp();
1258 app.setCentralAuth(true);
1259 List<EPApp> appList = new ArrayList<>();
1261 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
1262 Role role = new Role();
1263 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false, "406");
1264 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1265 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1266 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1267 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1268 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1269 Mockito.when(externalAccessRolesService.saveRoleForApplication(role, mockedRequest.getHeader("uebkey"))).thenReturn(externalRequestFieldsValidator);
1270 actualPortalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse, role);
1271 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1274 @Test(expected = NullPointerException.class)
1275 public void saveRoleNullExceptionTest() throws Exception
1277 List<EPApp> applicationList = new ArrayList<EPApp>();
1278 EPApp app = mockApp();
1279 applicationList.add(app);
1280 Role role = new Role();
1281 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1282 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false, "failed");
1283 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(),Matchers.anyString(),Matchers.anyString())).thenReturn(externalRequestFieldsValidator);
1284 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
1285 expectedportalRestResponse.setMessage("Failed to deleteRole");
1286 expectedportalRestResponse.setResponse("Failed");
1287 PortalRestStatusEnum portalRestStatusEnum = null;
1288 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
1289 PortalRestResponse<String> actualResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse, role);
1290 assertEquals(actualResponse, null);
1294 public void deleteRoleTest() throws Exception{
1295 PowerMockito.mockStatic(EcompPortalUtils.class);
1296 PowerMockito.mockStatic(SystemProperties.class);
1297 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1298 PowerMockito.mockStatic(PortalConstants.class);
1299 PortalRestResponse<String> actualPortalRestResponse = null;
1300 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
1301 expectedportalRestResponse.setMessage("Successfully Deleted");
1302 expectedportalRestResponse.setResponse("Success");
1303 PortalRestStatusEnum portalRestStatusEnum = null;
1304 EPUser user = mockUser.mockEPUser();
1305 List<EPUser> userList = new ArrayList<>();
1307 EPApp app = mockApp();
1308 app.setCentralAuth(true);
1309 List<EPApp> appList = new ArrayList<>();
1311 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
1312 String code ="test";
1313 boolean deleteResponse = true;
1314 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1315 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1316 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1317 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1318 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1319 Mockito.when(externalAccessRolesService.deleteRoleForApplication(code, mockedRequest.getHeader("uebkey"))).thenReturn(deleteResponse);
1320 actualPortalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, code);
1321 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1325 public void deleteRoleNegativeTest() throws Exception{
1326 PowerMockito.mockStatic(EcompPortalUtils.class);
1327 PowerMockito.mockStatic(SystemProperties.class);
1328 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1329 PowerMockito.mockStatic(PortalConstants.class);
1330 PortalRestResponse<String> actualPortalRestResponse = null;
1331 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
1332 expectedportalRestResponse.setMessage("Failed to delete Role for 'test");
1333 expectedportalRestResponse.setResponse("Failed");
1334 PortalRestStatusEnum portalRestStatusEnum = null;
1335 EPUser user = mockUser.mockEPUser();
1336 List<EPUser> userList = new ArrayList<>();
1338 EPApp app = mockApp();
1339 app.setCentralAuth(true);
1340 List<EPApp> appList = new ArrayList<>();
1342 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
1343 String code ="test";
1344 boolean deleteResponse = false;
1345 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1346 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1347 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1348 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1349 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1350 Mockito.when(externalAccessRolesService.deleteRoleForApplication(code, mockedRequest.getHeader("uebkey"))).thenReturn(deleteResponse);
1351 actualPortalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, code);
1352 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1356 public void deleteDependcyRoleRecordTest() throws Exception {
1357 ExternalRequestFieldsValidator removeResult = new ExternalRequestFieldsValidator(true, "success");
1358 PortalRestResponse<String> portalRestResponse = null;
1359 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
1360 expectedportalRestResponse.setMessage("Invalid uebkey!");
1361 expectedportalRestResponse.setResponse("Failed");
1362 PortalRestStatusEnum portalRestStatusEnum = null;
1363 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
1365 String LoginId = "loginId";
1366 List<EPApp> appList = new ArrayList<EPApp>();
1367 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1368 Mockito.when(mockedRequest.getHeader("LoginId")).thenReturn(LoginId);
1369 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1370 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(roleId, mockedRequest.getHeader("uebkey"), mockedRequest.getHeader("LoginId"))).thenReturn(removeResult);
1371 portalRestResponse = externalAccessRolesController.deleteDependencyRoleRecord(mockedRequest, mockedResponse, roleId);
1372 assertEquals(expectedportalRestResponse, portalRestResponse);