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.junit.Before;
55 import org.junit.Test;
56 import org.junit.runner.RunWith;
57 import org.mockito.InjectMocks;
58 import org.mockito.Matchers;
59 import org.mockito.Mock;
60 import org.mockito.Mockito;
61 import org.mockito.MockitoAnnotations;
62 import org.onap.portalapp.portal.core.MockEPUser;
63 import org.onap.portalapp.portal.domain.CentralV2RoleFunction;
64 import org.onap.portalapp.portal.domain.EPApp;
65 import org.onap.portalapp.portal.domain.EPUser;
66 import org.onap.portalapp.portal.ecomp.model.PortalRestResponse;
67 import org.onap.portalapp.portal.ecomp.model.PortalRestStatusEnum;
68 import org.onap.portalapp.portal.framework.MockitoTestSuite;
69 import org.onap.portalapp.portal.service.ExternalAccessRolesService;
70 import org.onap.portalapp.portal.service.ExternalAccessRolesServiceImpl;
71 import org.onap.portalapp.portal.transport.CentralRole;
72 import org.onap.portalapp.portal.transport.CentralRoleFunction;
73 import org.onap.portalapp.portal.transport.CentralV2Role;
74 import org.onap.portalapp.portal.transport.ExternalRequestFieldsValidator;
75 import org.onap.portalapp.portal.utils.EPCommonSystemProperties;
76 import org.onap.portalapp.portal.utils.EcompPortalUtils;
77 import org.onap.portalapp.portal.utils.PortalConstants;
78 import org.onap.portalsdk.core.domain.AuditLog;
79 import org.onap.portalsdk.core.domain.Role;
80 import org.onap.portalsdk.core.domain.User;
81 import org.onap.portalsdk.core.restful.domain.EcompRole;
82 import org.onap.portalsdk.core.restful.domain.EcompUser;
83 import org.onap.portalsdk.core.service.AuditService;
84 import org.onap.portalsdk.core.service.UserService;
85 import org.onap.portalsdk.core.service.UserServiceCentalizedImpl;
86 import org.onap.portalsdk.core.util.SystemProperties;
87 import org.powermock.api.mockito.PowerMockito;
88 import org.powermock.core.classloader.annotations.PrepareForTest;
89 import org.powermock.modules.junit4.PowerMockRunner;
90 import org.springframework.http.HttpStatus;
91 import org.springframework.http.ResponseEntity;
92 import org.springframework.web.client.HttpClientErrorException;
94 import com.fasterxml.jackson.core.JsonProcessingException;
95 import com.fasterxml.jackson.databind.ObjectMapper;
97 @RunWith(PowerMockRunner.class)
98 @PrepareForTest({ EcompPortalUtils.class, PortalConstants.class, SystemProperties.class,
99 EPCommonSystemProperties.class })
100 public class ExternalAccessRolesControllerTest {
103 ExternalAccessRolesService externalAccessRolesService = new ExternalAccessRolesServiceImpl();
106 ExternalAccessRolesController externalAccessRolesController = new ExternalAccessRolesController();
108 UserService userservice = new UserServiceCentalizedImpl();
111 AuditService auditService;
114 public void setup() {
115 MockitoAnnotations.initMocks(this);
118 AuditLog auditLog = new AuditLog();
120 MockitoTestSuite mockitoTestSuite = new MockitoTestSuite();
122 HttpServletRequest mockedRequest = mockitoTestSuite.getMockedRequest();
123 HttpServletResponse mockedResponse = mockitoTestSuite.getMockedResponse();
124 NullPointerException nullPointerException = new NullPointerException();
125 HttpClientErrorException httpClientErrorException = new HttpClientErrorException(HttpStatus.BAD_REQUEST, "Failed");
127 MockEPUser mockUser = new MockEPUser();
128 String loginId = "guestT";
129 String uebKey = "testUebKey";
132 public void getUserTest() throws Exception {
133 String reason = getInvalidKeyJson();
134 StringWriter sw = new StringWriter();
135 PrintWriter writer = new PrintWriter(sw);
136 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
137 List<EPUser> userList = new ArrayList<>();
138 Mockito.when(externalAccessRolesService.getUser(loginId)).thenReturn(userList);
139 externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId);
140 String result = sw.getBuffer().toString().trim();
141 assertEquals(reason, result);
145 public void getUserExceptionTest() throws Exception {
146 String reason = getInvalidKeyJson();
147 StringWriter sw = new StringWriter();
148 PrintWriter writer = new PrintWriter(sw);
149 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
150 externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId);
151 String result = sw.getBuffer().toString().trim();
152 assertEquals(reason, result);
155 public EPApp mockApp()
157 EPApp app = new EPApp();
159 app.setImageUrl("test");
160 app.setDescription("test");
161 app.setNotes("test");
164 app.setAppRestEndpoint("test");
165 app.setAlternateUrl("test");
167 app.setMlAppName("test");
168 app.setMlAppAdminId("test");
169 app.setUsername("test");
170 app.setAppPassword("test");
172 app.setEnabled(false);
173 app.setUebKey("test");
174 app.setUebSecret("test");
175 app.setUebTopicName("test");
180 @Test(expected = NullPointerException.class)
181 public void getRolesForAppTest() throws Exception {
182 List<EPApp> applicationList = new ArrayList<EPApp>();
183 List<CentralV2Role> answer = new ArrayList<>();
184 EPApp app = mockApp();
185 applicationList.add(app);
186 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
187 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
188 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey))).thenReturn(answer);
189 assertEquals(externalAccessRolesController.getRolesForApp(mockedRequest, mockedResponse), null);
192 @Test(expected = NullPointerException.class)
193 public void getRolesForAppExceptionTest() throws Exception {
194 List<EPApp> applicationList = new ArrayList<EPApp>();
195 EPApp app = mockApp();
196 applicationList.add(app);
197 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
198 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
199 externalAccessRolesController.getRolesForApp(mockedRequest,mockedResponse);
200 List<CentralV2Role> role = externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey));
201 assertEquals(null,role);
205 public void getRoleFunctionsListTest() throws Exception {
206 String reason = getInvalidKeyJson();
207 StringWriter sw = new StringWriter();
208 PrintWriter writer = new PrintWriter(sw);
209 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
210 List<CentralV2RoleFunction> answer = null;
211 Mockito.when(externalAccessRolesService.getRoleFuncList(mockedRequest.getHeader(uebKey))).thenReturn(null);
212 assertEquals(externalAccessRolesController.getRoleFunctionsList(mockedRequest, mockedResponse), answer);
213 String result = sw.getBuffer().toString().trim();
214 assertEquals(reason, result);
218 public void getRoleFunctionsListExceptionTest() throws Exception {
219 String reason = getInvalidKeyJson();
220 StringWriter sw = new StringWriter();
221 PrintWriter writer = new PrintWriter(sw);
222 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
223 externalAccessRolesController.getRoleFunctionsList(mockedRequest, mockedResponse);
224 String result = sw.getBuffer().toString().trim();
225 assertEquals(reason, result);
229 public void getRoleInfoTest() throws Exception {
230 String reason = getInvalidKeyJson();
231 StringWriter sw = new StringWriter();
232 PrintWriter writer = new PrintWriter(sw);
233 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
234 CentralV2Role answer = new CentralV2Role();
236 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader(uebKey)))
238 externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse, roleId);
239 String result = sw.getBuffer().toString().trim();
240 assertEquals(reason, result);
244 public void getRoleInfoExceptionTest() throws Exception {
245 String reason = getInvalidKeyJson();
246 StringWriter sw = new StringWriter();
247 PrintWriter writer = new PrintWriter(sw);
248 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
250 assertNull(externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse, roleId));
251 String result = sw.getBuffer().toString().trim();
252 assertEquals(reason, result);
256 public void getRoleFunctionTest() throws Exception {
257 EPApp mockApp = mockApp();
258 mockApp.setCentralAuth(true);
259 List<EPApp> mockAppList = new ArrayList<>();
260 mockAppList.add(mockApp);
261 StringWriter sw = new StringWriter();
262 PrintWriter writer = new PrintWriter(sw);
263 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
264 CentralV2RoleFunction roleFunction1 = new CentralV2RoleFunction();
265 CentralRoleFunction roleFunction2 = new CentralRoleFunction();
266 roleFunction1.setCode("test2");
267 String code = "test_menu";
268 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
269 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(mockAppList);
270 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
271 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(mockAppList.get(0))).thenReturn(response);
272 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader("uebkey")))
273 .thenReturn(roleFunction1);
274 CentralRoleFunction returnedValue = externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse, code);
275 assertEquals(returnedValue, roleFunction2);
276 String result = sw.getBuffer().toString().trim();
277 assertEquals("", result);
281 public void getRoleFunctionExceptionTest() throws Exception {
282 String reason = getInvalidKeyJson();
283 StringWriter sw = new StringWriter();
284 PrintWriter writer = new PrintWriter(sw);
285 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
286 String code = "test_menu";
287 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader(uebKey)))
288 .thenThrow(httpClientErrorException);
289 assertEquals(new CentralRoleFunction(),externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse, code));
290 String result = sw.getBuffer().toString().trim();
291 assertEquals(reason, result);
294 @Test(expected = NullPointerException.class)
295 public void saveRoleFunctionIfIsIsNotDeletedTest() throws Exception {
296 List<EPApp> applicationList = new ArrayList<EPApp>();
297 EPApp app = mockApp();
298 applicationList.add(app);
299 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
300 PortalRestResponse<String> portalRestResponse = null;
301 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
302 expectedportalRestResponse.setMessage("Invalid uebkey!");
303 expectedportalRestResponse.setResponse("Failed");
304 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
306 CentralV2RoleFunction centralV2RoleFunction = new CentralV2RoleFunction();
307 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(centralV2RoleFunction, app)).thenReturn(false);
308 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, data);
309 assertEquals(portalRestResponse, expectedportalRestResponse);
312 @Test(expected = NullPointerException.class)
313 public void saveRoleFunctionExceptionTest() 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 PortalRestResponse<String> portalRestResponse = null;
319 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
320 expectedportalRestResponse.setMessage("Invalid uebkey!");
321 expectedportalRestResponse.setResponse("Failed");
322 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
323 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, null);
324 System.out.println(portalRestResponse);
325 assertEquals(portalRestResponse, expectedportalRestResponse);
328 @Test(expected = NullPointerException.class)
329 public void saveRoleFunctionTest() throws Exception {
330 List<EPApp> applicationList = new ArrayList<EPApp>();
331 EPApp app = mockApp();
332 applicationList.add(app);
333 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
334 PortalRestResponse<String> portalRestResponse = null;
335 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
336 expectedportalRestResponse.setMessage(null);
337 expectedportalRestResponse.setResponse("Failed");
338 PortalRestStatusEnum portalRestStatusEnum = null;
339 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
341 CentralV2RoleFunction centralV2RoleFunction = new CentralV2RoleFunction();
342 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(centralV2RoleFunction, app)).thenReturn(true);
343 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, data);
344 System.out.println(portalRestResponse);
345 assertEquals(portalRestResponse, expectedportalRestResponse);
349 public void deleteRoleFunctionTest() throws Exception {
350 PowerMockito.mockStatic(EcompPortalUtils.class);
351 PowerMockito.mockStatic(SystemProperties.class);
352 PowerMockito.mockStatic(EPCommonSystemProperties.class);
353 PowerMockito.mockStatic(PortalConstants.class);
354 PortalRestResponse<String> portalRestResponse = null;
355 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
356 expectedportalRestResponse.setMessage("Successfully Deleted");
357 expectedportalRestResponse.setResponse("Success");
358 PortalRestStatusEnum portalRestStatusEnum = null;
359 EPUser user = mockUser.mockEPUser();
360 List<EPUser> userList = new ArrayList<>();
362 EPApp app = mockApp();
363 app.setCentralAuth(true);
364 List<EPApp> appList = new ArrayList<>();
366 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
367 String code ="testNew";
368 Mockito.when(mockedRequest.getHeader("LoginId")).thenReturn("guestT");
369 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
370 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
371 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
372 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
373 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
374 Mockito.when(externalAccessRolesService.deleteCentralRoleFunction(code, app)).thenReturn(true);
375 portalRestResponse = externalAccessRolesController.deleteRoleFunction(mockedRequest, mockedResponse, code);
376 assertEquals(portalRestResponse, expectedportalRestResponse);
380 public void getActiveRolesTest() throws Exception {
381 String reason = getInvalidKeyJson();
382 StringWriter sw = new StringWriter();
383 PrintWriter writer = new PrintWriter(sw);
384 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
385 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey))).thenReturn(null);
386 List<CentralRole> expectedCenRole = externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
387 assertNull(expectedCenRole);
388 String result = sw.getBuffer().toString().trim();
389 assertEquals(reason, result);
393 public void getActiveRolesExceptionTest() throws Exception {
394 String reason = getInvalidKeyJson();
395 StringWriter sw = new StringWriter();
396 PrintWriter writer = new PrintWriter(sw);
397 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
398 externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
399 String result = sw.getBuffer().toString().trim();
400 assertEquals(reason, result);
404 * It return JSON string which has error information
406 * @return JSON String
407 * @throws JsonProcessingException
409 private String getInvalidKeyJson() throws JsonProcessingException {
410 final Map<String,String> uebkeyResponse = new HashMap<>();
412 ObjectMapper mapper = new ObjectMapper();
413 uebkeyResponse.put("error","Invalid uebkey!");
414 reason = mapper.writeValueAsString(uebkeyResponse);
419 public void deleteDependcyRoleRecordExceptionTest() throws Exception {
420 PortalRestResponse<String> portalRestResponse = null;
421 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
422 expectedportalRestResponse.setMessage("Invalid uebkey!");
423 expectedportalRestResponse.setResponse("Failed");
424 PortalRestStatusEnum portalRestStatusEnum = null;
425 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
427 portalRestResponse = externalAccessRolesController.deleteDependencyRoleRecord(mockedRequest, mockedResponse, roleId);
428 assertEquals(expectedportalRestResponse, portalRestResponse);
432 public void bulkUploadFunctionsTest() throws Exception {
434 Mockito.when(externalAccessRolesService.bulkUploadFunctions(mockedRequest.getHeader(uebKey)))
436 PortalRestResponse<String> portalRestResponse = null;
437 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
438 expectedportalRestResponse.setMessage("Successfully added: 0");
439 expectedportalRestResponse.setResponse("Success");
440 PortalRestStatusEnum portalRestStatusEnum = null;
441 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
442 portalRestResponse = externalAccessRolesController.bulkUploadFunctions(mockedRequest, mockedResponse);
443 assertEquals(portalRestResponse, expectedportalRestResponse);
447 public void bulkUploadFunctionsExceptionTest() throws Exception {
448 Mockito.when(externalAccessRolesService.bulkUploadFunctions(mockedRequest.getHeader(uebKey)))
449 .thenThrow(httpClientErrorException);
450 PortalRestResponse<String> portalRestResponse = null;
451 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
452 expectedportalRestResponse.setMessage("Failed to bulkUploadFunctions");
453 expectedportalRestResponse.setResponse("Failed");
454 PortalRestStatusEnum portalRestStatusEnum = null;
455 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
456 portalRestResponse = externalAccessRolesController.bulkUploadFunctions(mockedRequest, mockedResponse);
457 assertEquals(portalRestResponse, expectedportalRestResponse);
461 public void bulkUploadRolesTest() throws Exception {
463 PortalRestResponse<String> portalRestResponse = null;
464 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
465 expectedportalRestResponse.setMessage("Successfully added: 0");
466 expectedportalRestResponse.setResponse("Success");
467 PortalRestStatusEnum portalRestStatusEnum = null;
468 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
469 Mockito.when(externalAccessRolesService.bulkUploadRoles(mockedRequest.getHeader(uebKey))).thenReturn(result);
470 portalRestResponse = externalAccessRolesController.bulkUploadRoles(mockedRequest, mockedResponse);
471 assertEquals(portalRestResponse, expectedportalRestResponse);
475 public void bulkUploadRolesTestException() throws Exception {
476 Mockito.when(externalAccessRolesService.bulkUploadRoles(mockedRequest.getHeader(uebKey)))
477 .thenThrow(httpClientErrorException);
478 PortalRestResponse<String> portalRestResponse = null;
479 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
480 expectedportalRestResponse.setMessage("Failed to bulkUploadRoles");
481 expectedportalRestResponse.setResponse("Failed");
482 PortalRestStatusEnum portalRestStatusEnum = null;
483 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
484 portalRestResponse = externalAccessRolesController.bulkUploadRoles(mockedRequest, mockedResponse);
485 assertEquals(portalRestResponse, expectedportalRestResponse);
489 public void bulkUploadRoleFunctionsTest() throws Exception {
491 PortalRestResponse<String> portalRestResponse = null;
492 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
493 expectedportalRestResponse.setMessage("Successfully added: 0");
494 expectedportalRestResponse.setResponse("Success");
495 PortalRestStatusEnum portalRestStatusEnum = null;
496 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
497 Mockito.when(externalAccessRolesService.bulkUploadRolesFunctions(mockedRequest.getHeader(uebKey)))
499 portalRestResponse = externalAccessRolesController.bulkUploadRoleFunctions(mockedRequest, mockedResponse);
500 assertEquals(portalRestResponse, expectedportalRestResponse);
504 public void bulkUploadRoleFunctionsException() throws Exception {
505 Mockito.when(externalAccessRolesService.bulkUploadRolesFunctions(mockedRequest.getHeader(uebKey)))
506 .thenThrow(httpClientErrorException);
507 PortalRestResponse<String> portalRestResponse = null;
508 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
509 expectedportalRestResponse.setMessage("Failed to bulkUploadRoleFunctions");
510 expectedportalRestResponse.setResponse("Failed");
511 PortalRestStatusEnum portalRestStatusEnum = null;
512 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
513 portalRestResponse = externalAccessRolesController.bulkUploadRoleFunctions(mockedRequest, mockedResponse);
514 assertEquals(portalRestResponse, expectedportalRestResponse);
518 public void bulkUploadUserRolesTest() throws Exception {
520 PortalRestResponse<String> portalRestResponse = null;
521 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
522 expectedportalRestResponse.setMessage("Successfully added: 0");
523 expectedportalRestResponse.setResponse("Success");
524 PortalRestStatusEnum portalRestStatusEnum = null;
525 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
526 Mockito.when(externalAccessRolesService.bulkUploadUserRoles(mockedRequest.getHeader(uebKey)))
528 portalRestResponse = externalAccessRolesController.bulkUploadUserRoles(mockedRequest, mockedResponse);
529 assertEquals(portalRestResponse, expectedportalRestResponse);
533 public void bulkUploadUserRolesExceptionTest() throws Exception {
534 Mockito.when(externalAccessRolesService.bulkUploadUserRoles(mockedRequest.getHeader(uebKey)))
535 .thenThrow(httpClientErrorException);
536 PortalRestResponse<String> portalRestResponse = null;
537 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
538 expectedportalRestResponse.setMessage("Failed to bulkUploadUserRoles");
539 expectedportalRestResponse.setResponse("Failed");
540 PortalRestStatusEnum portalRestStatusEnum = null;
541 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
542 portalRestResponse = externalAccessRolesController.bulkUploadUserRoles(mockedRequest, mockedResponse);
543 assertEquals(portalRestResponse, expectedportalRestResponse);
547 public void bulkUploadPartnerFunctionsTest() throws Exception {
548 PortalRestResponse<String> portalRestResponse = null;
549 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
550 expectedportalRestResponse.setMessage("Successfully added");
551 expectedportalRestResponse.setResponse("Success");
552 PortalRestStatusEnum portalRestStatusEnum = null;
553 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
554 portalRestResponse = externalAccessRolesController.bulkUploadPartnerFunctions(mockedRequest, mockedResponse, null);
555 assertEquals(portalRestResponse, expectedportalRestResponse);
560 public void bulkUploadPartnerRolesTest() throws Exception {
561 PortalRestResponse<String> portalRestResponse = null;
562 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
563 expectedportalRestResponse.setMessage("Successfully added");
564 expectedportalRestResponse.setResponse("Success");
565 PortalRestStatusEnum portalRestStatusEnum = null;
566 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
567 List<Role> upload = new ArrayList<>();
568 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoles(mockedRequest, mockedResponse,
570 assertEquals(portalRestResponse, expectedportalRestResponse);
574 public void bulkUploadPartnerRolesExceptionTest() throws Exception
576 ExternalAccessRolesService externalAccessRolesService = null;
577 PortalRestResponse<String> portalRestResponse = null;
578 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
579 expectedportalRestResponse.setMessage("Successfully added");
580 expectedportalRestResponse.setResponse("Success");
581 PortalRestStatusEnum portalRestStatusEnum = null;
582 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
583 List<Role> upload = new ArrayList<>();
584 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoles(mockedRequest, mockedResponse,
586 assertEquals(portalRestResponse, expectedportalRestResponse);
590 public void getMenuFunctionsTest() throws Exception {
591 String reason = getInvalidKeyJson();
592 StringWriter sw = new StringWriter();
593 PrintWriter writer = new PrintWriter(sw);
594 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
595 Mockito.when(externalAccessRolesService.getMenuFunctionsList(mockedRequest.getHeader(uebKey)))
597 List<String> expectedFunctionsList = externalAccessRolesController.getMenuFunctions(mockedRequest,
599 assertNull(expectedFunctionsList);
600 String result = sw.getBuffer().toString().trim();
601 assertEquals(reason, result);
605 public void getMenuFunctionsExceptionTest() throws Exception {
606 String reason = getInvalidKeyJson();
607 StringWriter sw = new StringWriter();
608 PrintWriter writer = new PrintWriter(sw);
609 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
610 Mockito.when(externalAccessRolesService.getMenuFunctionsList(mockedRequest.getHeader(uebKey)))
611 .thenThrow(httpClientErrorException);
612 assertNull(externalAccessRolesController.getMenuFunctions(mockedRequest, mockedResponse));
613 String result = sw.getBuffer().toString().trim();
614 assertEquals(reason, result);
619 public void saveRoleExceptionTest() throws Exception {
620 Role role = new Role();
621 PortalRestResponse<String> portalRestResponse = null;
622 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
623 expectedportalRestResponse.setMessage("Invalid uebkey!");
624 expectedportalRestResponse.setResponse("Failed");
625 PortalRestStatusEnum portalRestStatusEnum = null;
626 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
627 List<Role> upload = new ArrayList<>();
628 portalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse,role);
630 assertEquals(portalRestResponse, expectedportalRestResponse);
634 public void deleteRoleExceptionTest() throws Exception {
635 String role = "TestNew";
636 PortalRestResponse<String> portalRestResponse = null;
637 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
638 expectedportalRestResponse.setMessage("Invalid uebkey!");
639 expectedportalRestResponse.setResponse("Failed");
640 PortalRestStatusEnum portalRestStatusEnum = null;
641 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
642 portalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse,role);
643 assertEquals(portalRestResponse, expectedportalRestResponse);
648 public void bulkUploadPartnerRoleFunctionsTest() throws Exception {
649 PortalRestResponse<String> portalRestResponse = null;
650 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
651 expectedportalRestResponse.setMessage("Successfully added");
652 expectedportalRestResponse.setResponse("Success");
653 PortalRestStatusEnum portalRestStatusEnum = null;
654 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
655 List<Role> upload = new ArrayList<>();
656 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoleFunctions(mockedRequest, mockedResponse,upload);
657 assertEquals(portalRestResponse, expectedportalRestResponse);
661 public void getUsersOfApplicationTest() throws Exception
663 List<EcompUser> users = new ArrayList<>();
664 EcompUser user = new EcompUser();
665 user.setOrgUserId("guestT");
667 StringWriter sw = new StringWriter();
668 PrintWriter writer = new PrintWriter(sw);
669 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
670 List<EPApp> applicationList = new ArrayList<EPApp>();
671 EPApp app = mockApp();
672 app.setCentralAuth(true);
673 applicationList.add(app);
674 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
675 Mockito.when(externalAccessRolesService.getAllAppUsers(mockedRequest.getHeader(uebKey))).thenReturn(users);
676 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
677 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
678 List<EcompUser> expectedUsers = externalAccessRolesController.getUsersOfApplication(mockedRequest, mockedResponse);
679 assertEquals(expectedUsers, users);
682 @Test(expected = Exception.class)
683 public void getUsersOfApplicationExceptionTest() throws Exception
685 List<EcompUser> users = new ArrayList<>();
686 EcompUser user = new EcompUser();
687 user.setOrgUserId("guestT");
689 Mockito.when(externalAccessRolesService.getAllAppUsers(mockedRequest.getHeader(uebKey))).thenThrow(nullPointerException);
690 assertNull(externalAccessRolesController.getUsersOfApplication(mockedRequest, mockedResponse));
693 @Test(expected = NullPointerException.class)
694 public void deleteRoleV2Test() throws Exception
696 List<EPApp> applicationList = new ArrayList<EPApp>();
697 EPApp app = mockApp();
698 applicationList.add(app);
699 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
700 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(true, "Success");
701 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(),Matchers.anyString(),Matchers.anyString())).thenReturn(externalRequestFieldsValidator);
702 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
703 expectedportalRestResponse.setMessage("Successfully Deleted");
704 expectedportalRestResponse.setResponse("Success");
705 PortalRestStatusEnum portalRestStatusEnum = null;
706 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
707 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, (long)1);
708 assertNull(actualResponse);
712 public void deleteRoleV2InvalidUebKeyTest() throws Exception
714 List<EPApp> applicationList = new ArrayList<EPApp>();
715 EPApp app = mockApp();
716 applicationList.add(app);
717 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenThrow(new Exception("Invalid uebkey!"));
718 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
719 expectedportalRestResponse.setMessage("Invalid uebkey!");
720 expectedportalRestResponse.setResponse("Failed");
721 PortalRestStatusEnum portalRestStatusEnum = null;
722 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
723 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, (long)1);
724 assertEquals(actualResponse, expectedportalRestResponse);
728 public void deleteRoleV2InvalidUebKeyWithDiffErrorTest() throws Exception
730 List<EPApp> applicationList = new ArrayList<EPApp>();
731 EPApp app = mockApp();
732 applicationList.add(app);
733 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenThrow(new Exception("test"));
734 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
735 expectedportalRestResponse.setMessage("test");
736 expectedportalRestResponse.setResponse("Failed");
737 PortalRestStatusEnum portalRestStatusEnum = null;
738 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
739 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, (long)1);
740 assertEquals(actualResponse, expectedportalRestResponse);
744 @Test(expected = NullPointerException.class)
745 public void deleteRoleV2ExceptionTest() throws Exception
747 List<EPApp> applicationList = new ArrayList<EPApp>();
748 EPApp app = mockApp();
749 applicationList.add(app);
750 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
751 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false, "failed");
752 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(),Matchers.anyString(),Matchers.anyString())).thenReturn(externalRequestFieldsValidator);
753 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
754 expectedportalRestResponse.setMessage("Failed to deleteRole");
755 expectedportalRestResponse.setResponse("Failed");
756 PortalRestStatusEnum portalRestStatusEnum = null;
757 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
758 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, (long)1);
759 assertEquals(actualResponse, null);
763 public void getEpUserNullTest() throws Exception{
764 List<EPApp> applicationList = new ArrayList<EPApp>();
765 EPApp app = mockApp();
766 app.setUebKey("uebKey");
767 app.setCentralAuth(true);
768 applicationList.add(app);
769 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
770 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
771 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
772 assertNull(externalAccessRolesController.getEcompUser(mockedRequest, mockedResponse, "test12"));
776 public void getEpUserTest() throws Exception{
777 List<EPApp> applicationList = new ArrayList<EPApp>();
778 EPApp app = mockApp();
779 app.setUebKey("uebKey");
780 app.setCentralAuth(true);
781 applicationList.add(app);
782 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
783 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
784 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
785 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\"}";
786 Mockito.when(externalAccessRolesService.getV2UserWithRoles("test12", mockedRequest.getHeader(uebKey))).thenReturn(user);
787 User EPuser = new User();
788 EPuser.setFirstName("test");
789 Mockito.when(userservice.userMapper(user)).thenReturn(EPuser);
790 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\":[]}";
791 assertEquals(externalAccessRolesController.getEcompUser(mockedRequest, mockedResponse, "test12"),res);
795 public void getEpUserExceptionTest() throws Exception{
796 List<EPApp> applicationList = new ArrayList<EPApp>();
797 EPApp app = mockApp();
798 app.setCentralAuth(true);
799 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
800 StringWriter sw = new StringWriter();
801 PrintWriter writer = new PrintWriter(sw);
802 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
803 assertNull(externalAccessRolesController.getEcompUser(mockedRequest, mockedResponse, "test12"));
807 public void getEPRolesOfApplicationTest() throws Exception
809 List<EPApp> applicationList = new ArrayList<EPApp>();
810 EPApp app = mockApp();
811 app.setUebKey("uebKey");
812 app.setCentralAuth(true);
813 applicationList.add(app);
814 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
815 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
816 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
817 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
818 List<CentralV2Role> cenRoleList = new ArrayList<>();
819 CentralV2Role role = new CentralV2Role();
820 role.setName("test");
821 cenRoleList.add(role);
822 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey))).thenReturn(cenRoleList);
823 List<EcompRole> ecompRoles = new ArrayList<>();
824 EcompRole eprole = new EcompRole();
825 eprole.setName("test");
826 ecompRoles.add(eprole);
827 assertEquals(ecompRoles,externalAccessRolesController.getEcompRolesOfApplication(mockedRequest, mockedResponse));
830 public void getEPRolesOfApplicationNullTest() throws Exception
832 List<EPApp> applicationList = new ArrayList<EPApp>();
833 EPApp app = mockApp();
834 app.setUebKey("uebKey");
835 app.setCentralAuth(true);
836 applicationList.add(app);
837 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
838 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
839 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
840 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
841 List<CentralV2Role> cenRoleList = new ArrayList<>();
842 CentralV2Role role = new CentralV2Role();
843 role.setName("test");
844 cenRoleList.add(role);
845 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey))).thenReturn(null);
846 assertNull(externalAccessRolesController.getEcompRolesOfApplication(mockedRequest, mockedResponse));
851 public void getEPRolesOfApplicationExceptionTest() throws Exception
853 List<EPApp> applicationList = new ArrayList<EPApp>();
854 EPApp app = mockApp();
855 app.setCentralAuth(true);
856 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
857 StringWriter sw = new StringWriter();
858 PrintWriter writer = new PrintWriter(sw);
859 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
860 assertNull(externalAccessRolesController.getEcompRolesOfApplication(mockedRequest, mockedResponse));