2 * ============LICENSE_START==========================================
4 * ===================================================================
5 * Copyright © 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============================================
36 * ECOMP is a trademark and service mark of AT&T Intellectual Property.
38 package org.openecomp.portalapp.portal.controller;
41 import static org.junit.Assert.assertEquals;
42 import static org.junit.Assert.assertNull;
44 import java.util.ArrayList;
45 import java.util.List;
47 import javax.servlet.http.HttpServletRequest;
48 import javax.servlet.http.HttpServletResponse;
50 import org.junit.Before;
51 import org.junit.Test;
52 import org.mockito.InjectMocks;
53 import org.mockito.Mock;
54 import org.mockito.Mockito;
55 import org.mockito.MockitoAnnotations;
56 import org.openecomp.portalapp.portal.core.MockEPUser;
57 import org.openecomp.portalapp.portal.domain.CentralRoleFunction;
58 import org.openecomp.portalapp.portal.domain.EPApp;
59 import org.openecomp.portalapp.portal.domain.EPUser;
60 import org.openecomp.portalapp.portal.ecomp.model.PortalRestResponse;
61 import org.openecomp.portalapp.portal.ecomp.model.PortalRestStatusEnum;
62 import org.openecomp.portalapp.portal.framework.MockitoTestSuite;
63 import org.openecomp.portalapp.portal.service.ExternalAccessRolesService;
64 import org.openecomp.portalapp.portal.service.ExternalAccessRolesServiceImpl;
65 import org.openecomp.portalapp.portal.transport.CentralRole;
66 import org.openecomp.portalsdk.core.domain.AuditLog;
67 import org.openecomp.portalsdk.core.domain.Role;
68 import org.openecomp.portalsdk.core.restful.domain.EcompUser;
69 import org.springframework.http.HttpStatus;
70 import org.springframework.web.client.HttpClientErrorException;
71 public class ExternalAccessRolesControllerTest {
74 ExternalAccessRolesService externalAccessRolesService = new ExternalAccessRolesServiceImpl();
77 ExternalAccessRolesController externalAccessRolesController = new ExternalAccessRolesController();
81 MockitoAnnotations.initMocks(this);
84 AuditLog auditLog = new AuditLog();
86 MockitoTestSuite mockitoTestSuite = new MockitoTestSuite();
88 HttpServletRequest mockedRequest = mockitoTestSuite.getMockedRequest();
89 HttpServletResponse mockedResponse = mockitoTestSuite.getMockedResponse();
90 NullPointerException nullPointerException = new NullPointerException();
91 HttpClientErrorException httpClientErrorException = new HttpClientErrorException(HttpStatus.BAD_REQUEST, "Failed");
93 MockEPUser mockUser = new MockEPUser();
94 String loginId = "guestT";
95 String uebKey = "testUebKey";
98 public void getUserTest() throws Exception {
99 List<EPUser> userList = new ArrayList<>();
100 Mockito.when(externalAccessRolesService.getUser(loginId)).thenReturn(userList);
101 assertNull(externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId));
105 public void getUserExceptionTest() throws Exception {
106 Mockito.when(externalAccessRolesService.getUser(loginId))
107 .thenThrow(nullPointerException);
108 assertNull(externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId));
111 public EPApp mockApp()
113 EPApp app = new EPApp();
115 app.setImageUrl("test");
116 app.setDescription("test");
117 app.setNotes("test");
120 app.setAppRestEndpoint("test");
121 app.setAlternateUrl("test");
123 app.setMlAppName("test");
124 app.setMlAppAdminId("test");
125 app.setUsername("test");
126 app.setAppPassword("test");
128 app.setEnabled(false);
129 app.setUebKey("test");
130 app.setUebSecret("test");
131 app.setUebTopicName("test");
137 public void getRolesForAppTest() throws Exception {
138 List<EPApp> applicationList = new ArrayList<EPApp>();
139 List<CentralRole> answer = new ArrayList<>();
140 EPApp app = mockApp();
141 applicationList.add(app);
142 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
143 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
144 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey))).thenReturn(answer);
145 assertEquals(externalAccessRolesController.getRolesForApp(mockedRequest, mockedResponse), answer);
149 public void getRolesForAppExceptionTest() throws Exception {
150 List<EPApp> applicationList = new ArrayList<EPApp>();
151 List<CentralRole> answer = new ArrayList<>();
152 EPApp app = mockApp();
153 applicationList.add(app);
154 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
155 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
156 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey)))
157 .thenThrow(httpClientErrorException);
158 assertNull(externalAccessRolesController.getRolesForApp(mockedRequest, mockedResponse));
162 public void getRoleFunctionsListTest() throws Exception {
163 List<CentralRoleFunction> answer = new ArrayList<>();
164 Mockito.when(externalAccessRolesService.getRoleFuncList(mockedRequest.getHeader(uebKey))).thenReturn(answer);
165 assertEquals(externalAccessRolesController.getRoleFunctionsList(mockedRequest, mockedResponse), answer);
169 public void getRoleFunctionsListExceptionTest() throws Exception {
170 Mockito.when(externalAccessRolesService.getRoleFuncList(mockedRequest.getHeader(uebKey)))
171 .thenThrow(httpClientErrorException);
172 assertNull(externalAccessRolesController.getRoleFunctionsList(mockedRequest, mockedResponse));
176 public void getRoleInfoTest() throws Exception {
177 CentralRole answer = new CentralRole();
179 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader(uebKey)))
181 assertEquals(externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse, roleId), answer);
185 public void getRoleInfoExceptionTest() throws Exception {
187 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader(uebKey)))
188 .thenThrow(httpClientErrorException);
189 assertNull(externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse, roleId));
193 public void getRoleFunctionTest() throws Exception {
194 CentralRoleFunction centralRoleFunction = new CentralRoleFunction();
195 String code = "test_menu";
196 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader(uebKey)))
197 .thenReturn(centralRoleFunction);
198 assertEquals(externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse, code),
199 centralRoleFunction);
203 public void getRoleFunctionExceptionTest() throws Exception {
204 String code = "test_menu";
205 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader(uebKey)))
206 .thenThrow(httpClientErrorException);
207 assertNull(externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse, code));
211 public void saveRoleFunctionIfIsIsNotDeletedTest() throws Exception {
212 List<EPApp> applicationList = new ArrayList<EPApp>();
213 EPApp app = mockApp();
214 applicationList.add(app);
215 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
216 PortalRestResponse<String> portalRestResponse = null;
217 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
218 expectedportalRestResponse.setMessage(null);
219 expectedportalRestResponse.setResponse("Failed");
220 PortalRestStatusEnum portalRestStatusEnum = null;
221 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
223 CentralRoleFunction centralRoleFunction = new CentralRoleFunction();
224 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(centralRoleFunction, app)).thenReturn(false);
225 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, data);
226 assertEquals(portalRestResponse, expectedportalRestResponse);
230 public void saveRoleFunctionExceptionTest() throws Exception {
231 List<EPApp> applicationList = new ArrayList<EPApp>();
232 EPApp app = mockApp();
233 applicationList.add(app);
234 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
235 PortalRestResponse<String> portalRestResponse = null;
236 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
237 expectedportalRestResponse.setMessage(null);
238 expectedportalRestResponse.setResponse("Failed");
239 PortalRestStatusEnum portalRestStatusEnum = null;
240 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
242 CentralRoleFunction centralRoleFunction = new CentralRoleFunction();
243 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(centralRoleFunction, app)).thenThrow(nullPointerException);
244 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, data);
245 System.out.println(portalRestResponse);
246 assertEquals(portalRestResponse, expectedportalRestResponse);
250 public void saveRoleFunctionTest() throws Exception {
251 List<EPApp> applicationList = new ArrayList<EPApp>();
252 List<CentralRole> answer = new ArrayList<>();
253 EPApp app = mockApp();
254 applicationList.add(app);
255 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
256 PortalRestResponse<String> portalRestResponse = null;
257 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
258 expectedportalRestResponse.setMessage(null);
259 expectedportalRestResponse.setResponse("Failed");
260 PortalRestStatusEnum portalRestStatusEnum = null;
261 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
263 CentralRoleFunction centralRoleFunction = new CentralRoleFunction();
264 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(centralRoleFunction, app)).thenReturn(true);
265 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, data);
266 System.out.println(portalRestResponse);
267 assertEquals(portalRestResponse, expectedportalRestResponse);
271 // public void deleteRoleFunctionTest() throws Exception {
272 // PortalRestResponse<String> portalRestResponse = null;
273 // PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
274 // expectedportalRestResponse.setMessage("Successfully Deleted");
275 // expectedportalRestResponse.setResponse("Success");
276 // PortalRestStatusEnum portalRestStatusEnum = null;
277 // EPUser user = mockUser.mockEPUser();
278 // EPApp app = mockApp();
279 // expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
280 // String code ="testNew";
281 // Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LOGIN_ID"))).thenReturn((List<EPUser>) user);
282 // Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("UEBKEY")).get(0)).thenReturn(app);
283 // Mockito.when(externalAccessRolesService.deleteCentralRoleFunction(code, app)).thenReturn(true);
284 // portalRestResponse = externalAccessRolesController.deleteRoleFunction(mockedRequest, mockedResponse, code);
285 // assertEquals(portalRestResponse, expectedportalRestResponse);
289 public void getActiveRolesTest() throws Exception {
290 List<CentralRole> cenRole = new ArrayList<>();
291 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey))).thenReturn(cenRole);
292 List<CentralRole> expectedCenRole = externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
293 assertEquals(expectedCenRole, cenRole);
297 public void getActiveRolesExceptionTest() throws Exception {
298 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey)))
299 .thenThrow(httpClientErrorException);
300 assertNull(externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse));
304 public void deleteDependcyRoleRecordExceptionTest() throws Exception {
305 PortalRestResponse<String> portalRestResponse = null;
306 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
307 expectedportalRestResponse.setMessage("Failed to deleteDependencyRoleRecord");
308 expectedportalRestResponse.setResponse("Failed");
309 PortalRestStatusEnum portalRestStatusEnum = null;
310 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
312 portalRestResponse = externalAccessRolesController.deleteDependencyRoleRecord(mockedRequest, mockedResponse, roleId);
313 assertEquals(expectedportalRestResponse, portalRestResponse);
317 public void bulkUploadFunctionsTest() throws Exception {
319 Mockito.when(externalAccessRolesService.bulkUploadFunctions(mockedRequest.getHeader(uebKey)))
321 PortalRestResponse<String> portalRestResponse = null;
322 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
323 expectedportalRestResponse.setMessage("Successfully added: 0");
324 expectedportalRestResponse.setResponse("Success");
325 PortalRestStatusEnum portalRestStatusEnum = null;
326 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
327 portalRestResponse = externalAccessRolesController.bulkUploadFunctions(mockedRequest, mockedResponse);
328 assertEquals(portalRestResponse, expectedportalRestResponse);
332 public void bulkUploadFunctionsExceptionTest() throws Exception {
333 Mockito.when(externalAccessRolesService.bulkUploadFunctions(mockedRequest.getHeader(uebKey)))
334 .thenThrow(httpClientErrorException);
335 PortalRestResponse<String> portalRestResponse = null;
336 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
337 expectedportalRestResponse.setMessage("Failed to bulkUploadFunctions");
338 expectedportalRestResponse.setResponse("Failed");
339 PortalRestStatusEnum portalRestStatusEnum = null;
340 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
341 portalRestResponse = externalAccessRolesController.bulkUploadFunctions(mockedRequest, mockedResponse);
342 assertEquals(portalRestResponse, expectedportalRestResponse);
346 public void bulkUploadRolesTest() throws Exception {
348 PortalRestResponse<String> portalRestResponse = null;
349 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
350 expectedportalRestResponse.setMessage("Successfully added: 0");
351 expectedportalRestResponse.setResponse("Success");
352 PortalRestStatusEnum portalRestStatusEnum = null;
353 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
354 Mockito.when(externalAccessRolesService.bulkUploadRoles(mockedRequest.getHeader(uebKey))).thenReturn(result);
355 portalRestResponse = externalAccessRolesController.bulkUploadRoles(mockedRequest, mockedResponse);
356 assertEquals(portalRestResponse, expectedportalRestResponse);
360 public void bulkUploadRolesTestException() throws Exception {
361 Mockito.when(externalAccessRolesService.bulkUploadRoles(mockedRequest.getHeader(uebKey)))
362 .thenThrow(httpClientErrorException);
363 PortalRestResponse<String> portalRestResponse = null;
364 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
365 expectedportalRestResponse.setMessage("Failed to bulkUploadRoles");
366 expectedportalRestResponse.setResponse("Failed");
367 PortalRestStatusEnum portalRestStatusEnum = null;
368 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
369 portalRestResponse = externalAccessRolesController.bulkUploadRoles(mockedRequest, mockedResponse);
370 assertEquals(portalRestResponse, expectedportalRestResponse);
374 public void bulkUploadRoleFunctionsTest() throws Exception {
376 PortalRestResponse<String> portalRestResponse = null;
377 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
378 expectedportalRestResponse.setMessage("Successfully added: 0");
379 expectedportalRestResponse.setResponse("Success");
380 PortalRestStatusEnum portalRestStatusEnum = null;
381 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
382 Mockito.when(externalAccessRolesService.bulkUploadRolesFunctions(mockedRequest.getHeader(uebKey)))
384 portalRestResponse = externalAccessRolesController.bulkUploadRoleFunctions(mockedRequest, mockedResponse);
385 assertEquals(portalRestResponse, expectedportalRestResponse);
389 public void bulkUploadRoleFunctionsException() throws Exception {
390 Mockito.when(externalAccessRolesService.bulkUploadRolesFunctions(mockedRequest.getHeader(uebKey)))
391 .thenThrow(httpClientErrorException);
392 PortalRestResponse<String> portalRestResponse = null;
393 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
394 expectedportalRestResponse.setMessage("Failed to bulkUploadRoleFunctions");
395 expectedportalRestResponse.setResponse("Failed");
396 PortalRestStatusEnum portalRestStatusEnum = null;
397 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
398 portalRestResponse = externalAccessRolesController.bulkUploadRoleFunctions(mockedRequest, mockedResponse);
399 assertEquals(portalRestResponse, expectedportalRestResponse);
403 public void bulkUploadUserRolesTest() throws Exception {
405 PortalRestResponse<String> portalRestResponse = null;
406 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
407 expectedportalRestResponse.setMessage("Successfully added: 0");
408 expectedportalRestResponse.setResponse("Success");
409 PortalRestStatusEnum portalRestStatusEnum = null;
410 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
411 Mockito.when(externalAccessRolesService.bulkUploadUserRoles(mockedRequest.getHeader(uebKey)))
413 portalRestResponse = externalAccessRolesController.bulkUploadUserRoles(mockedRequest, mockedResponse);
414 assertEquals(portalRestResponse, expectedportalRestResponse);
418 public void bulkUploadUserRolesExceptionTest() throws Exception {
419 Mockito.when(externalAccessRolesService.bulkUploadUserRoles(mockedRequest.getHeader(uebKey)))
420 .thenThrow(httpClientErrorException);
421 PortalRestResponse<String> portalRestResponse = null;
422 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
423 expectedportalRestResponse.setMessage("Failed to bulkUploadUserRoles");
424 expectedportalRestResponse.setResponse("Failed");
425 PortalRestStatusEnum portalRestStatusEnum = null;
426 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
427 portalRestResponse = externalAccessRolesController.bulkUploadUserRoles(mockedRequest, mockedResponse);
428 assertEquals(portalRestResponse, expectedportalRestResponse);
432 public void bulkUploadPartnerFunctionsTest() throws Exception {
433 PortalRestResponse<String> portalRestResponse = null;
434 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
435 expectedportalRestResponse.setMessage("Successfully added");
436 expectedportalRestResponse.setResponse("Success");
437 PortalRestStatusEnum portalRestStatusEnum = null;
438 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
439 portalRestResponse = externalAccessRolesController.bulkUploadPartnerFunctions(mockedRequest, mockedResponse, null);
440 assertEquals(portalRestResponse, expectedportalRestResponse);
445 public void bulkUploadPartnerRolesTest() throws Exception {
446 PortalRestResponse<String> portalRestResponse = null;
447 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
448 expectedportalRestResponse.setMessage("Successfully added");
449 expectedportalRestResponse.setResponse("Success");
450 PortalRestStatusEnum portalRestStatusEnum = null;
451 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
452 List<Role> upload = new ArrayList<>();
453 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoles(mockedRequest, mockedResponse,
455 assertEquals(portalRestResponse, expectedportalRestResponse);
459 public void bulkUploadPartnerRolesExceptionTest() throws Exception
461 ExternalAccessRolesService externalAccessRolesService = null;
462 PortalRestResponse<String> portalRestResponse = null;
463 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
464 expectedportalRestResponse.setMessage("Successfully added");
465 expectedportalRestResponse.setResponse("Success");
466 PortalRestStatusEnum portalRestStatusEnum = null;
467 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
468 List<Role> upload = new ArrayList<>();
469 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoles(mockedRequest, mockedResponse,
471 assertEquals(portalRestResponse, expectedportalRestResponse);
475 public void getMenuFunctionsTest() throws Exception {
476 List<String> functionsList = new ArrayList<>();
477 Mockito.when(externalAccessRolesService.getMenuFunctionsList(mockedRequest.getHeader(uebKey)))
478 .thenReturn(functionsList);
479 List<String> expectedFunctionsList = externalAccessRolesController.getMenuFunctions(mockedRequest,
481 assertEquals(functionsList, expectedFunctionsList);
485 public void getMenuFunctionsExceptionTest() throws Exception {
486 Mockito.when(externalAccessRolesService.getMenuFunctionsList(mockedRequest.getHeader(uebKey)))
487 .thenThrow(httpClientErrorException);
488 assertNull(externalAccessRolesController.getMenuFunctions(mockedRequest, mockedResponse));
492 // public void getUsersOfApplicationTest() throws Exception {
493 // List<String> users = new ArrayList<>();
494 // Mockito.when(externalAccessRolesService.getAllUsers(mockedRequest.getHeader(uebKey))).thenReturn(users);
495 // List<String> expectedusers = externalAccessRolesController.getUsersOfApplication(mockedRequest, mockedResponse);
496 // assertEquals(users, expectedusers);
500 // public void getUsersOfApplicationExceptionTest() throws Exception {
501 // Mockito.when(externalAccessRolesService.getAllUsers(mockedRequest.getHeader(uebKey)))
502 // .thenThrow(httpClientErrorException);
503 // assertNull(externalAccessRolesController.getUsersOfApplication(mockedRequest, mockedResponse));
507 public void saveRoleExceptionTest() throws Exception {
508 Role role = new Role();
509 PortalRestResponse<String> portalRestResponse = null;
510 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
511 expectedportalRestResponse.setMessage("Failed to saveRole");
512 expectedportalRestResponse.setResponse("Failed");
513 PortalRestStatusEnum portalRestStatusEnum = null;
514 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
515 List<Role> upload = new ArrayList<>();
516 portalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse,role);
517 assertEquals(portalRestResponse, expectedportalRestResponse);
521 public void deleteRoleExceptionTest() throws Exception {
522 String role = "TestNew";
523 PortalRestResponse<String> portalRestResponse = null;
524 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
525 expectedportalRestResponse.setMessage("Failed to deleteRole for 'TestNew'");
526 expectedportalRestResponse.setResponse("Failed");
527 PortalRestStatusEnum portalRestStatusEnum = null;
528 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
529 portalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse,role);
530 assertEquals(portalRestResponse, expectedportalRestResponse);
535 public void bulkUploadPartnerRoleFunctionsTest() throws Exception {
536 PortalRestResponse<String> portalRestResponse = null;
537 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
538 expectedportalRestResponse.setMessage("Successfully added");
539 expectedportalRestResponse.setResponse("Success");
540 PortalRestStatusEnum portalRestStatusEnum = null;
541 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
542 List<Role> upload = new ArrayList<>();
543 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoleFunctions(mockedRequest, mockedResponse,upload);
544 assertEquals(portalRestResponse, expectedportalRestResponse);
548 public void getUsersOfApplicationTest() throws Exception
550 List<EcompUser> users = new ArrayList<>();
551 EcompUser user = new EcompUser();
552 user.setOrgUserId("guestT");
554 Mockito.when(externalAccessRolesService.getAllAppUsers(mockedRequest.getHeader(uebKey))).thenReturn(users);
555 List<EcompUser> expectedUsers = externalAccessRolesController.getUsersOfApplication(mockedRequest, mockedResponse);
556 assertEquals(expectedUsers, users);
559 @Test(expected = Exception.class)
560 public void getUsersOfApplicationExceptionTest() throws Exception
562 List<EcompUser> users = new ArrayList<>();
563 EcompUser user = new EcompUser();
564 user.setOrgUserId("guestT");
566 Mockito.when(externalAccessRolesService.getAllAppUsers(mockedRequest.getHeader(uebKey))).thenThrow(nullPointerException);
567 assertNull(externalAccessRolesController.getUsersOfApplication(mockedRequest, mockedResponse));