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.CentralV2Role;
75 import org.onap.portalapp.portal.transport.ExternalRequestFieldsValidator;
76 import org.onap.portalapp.portal.utils.EPCommonSystemProperties;
77 import org.onap.portalapp.portal.utils.EcompPortalUtils;
78 import org.onap.portalapp.portal.utils.PortalConstants;
79 import org.onap.portalsdk.core.domain.AuditLog;
80 import org.onap.portalsdk.core.domain.Role;
81 import org.onap.portalsdk.core.domain.User;
82 import org.onap.portalsdk.core.restful.domain.EcompRole;
83 import org.onap.portalsdk.core.restful.domain.EcompUser;
84 import org.onap.portalsdk.core.service.AuditService;
85 import org.onap.portalsdk.core.service.UserService;
86 import org.onap.portalsdk.core.service.UserServiceCentalizedImpl;
87 import org.onap.portalsdk.core.util.SystemProperties;
88 import org.powermock.api.mockito.PowerMockito;
89 import org.powermock.core.classloader.annotations.PrepareForTest;
90 import org.powermock.modules.junit4.PowerMockRunner;
91 import org.springframework.http.HttpStatus;
92 import org.springframework.http.ResponseEntity;
93 import org.springframework.test.util.MatcherAssertionErrors;
94 import org.springframework.web.client.HttpClientErrorException;
96 import com.fasterxml.jackson.core.JsonProcessingException;
97 import com.fasterxml.jackson.databind.DeserializationFeature;
98 import com.fasterxml.jackson.databind.ObjectMapper;
100 @RunWith(PowerMockRunner.class)
101 @PrepareForTest({ EcompPortalUtils.class, PortalConstants.class, SystemProperties.class,
102 EPCommonSystemProperties.class })
103 public class ExternalAccessRolesControllerTest {
106 ExternalAccessRolesService externalAccessRolesService = new ExternalAccessRolesServiceImpl();
109 ExternalAccessRolesController externalAccessRolesController = new ExternalAccessRolesController();
111 UserService userservice = new UserServiceCentalizedImpl();
114 AuditService auditService;
117 public void setup() {
118 MockitoAnnotations.initMocks(this);
121 AuditLog auditLog = new AuditLog();
123 MockitoTestSuite mockitoTestSuite = new MockitoTestSuite();
125 HttpServletRequest mockedRequest = mockitoTestSuite.getMockedRequest();
126 HttpServletResponse mockedResponse = mockitoTestSuite.getMockedResponse();
127 NullPointerException nullPointerException = new NullPointerException();
128 HttpClientErrorException httpClientErrorException = new HttpClientErrorException(HttpStatus.BAD_REQUEST, "Failed");
130 MockEPUser mockUser = new MockEPUser();
131 String loginId = "guestT";
132 String uebKey = "testUebKey";
135 public void getUserTest() throws Exception {
136 String reason = getInvalidKeyJson();
137 StringWriter sw = new StringWriter();
138 PrintWriter writer = new PrintWriter(sw);
139 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
140 List<EPUser> userList = new ArrayList<>();
141 Mockito.when(externalAccessRolesService.getUser(loginId)).thenReturn(userList);
142 externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId);
143 String result = sw.getBuffer().toString().trim();
144 assertEquals(reason, result);
148 public void getUserExceptionTest() throws Exception {
149 String reason = getInvalidKeyJson();
150 StringWriter sw = new StringWriter();
151 PrintWriter writer = new PrintWriter(sw);
152 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
153 externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId);
154 String result = sw.getBuffer().toString().trim();
155 assertEquals(reason, result);
158 public EPApp mockApp()
160 EPApp app = new EPApp();
162 app.setImageUrl("test");
163 app.setDescription("test");
164 app.setNotes("test");
167 app.setAppRestEndpoint("test");
168 app.setAlternateUrl("test");
170 app.setMlAppName("test");
171 app.setMlAppAdminId("test");
172 app.setUsername("test");
173 app.setAppPassword("test");
175 app.setEnabled(false);
176 app.setUebKey("test");
177 app.setUebSecret("test");
178 app.setUebTopicName("test");
183 @Test(expected = NullPointerException.class)
184 public void getRolesForAppTest() throws Exception {
185 List<EPApp> applicationList = new ArrayList<EPApp>();
186 List<CentralV2Role> answer = new ArrayList<>();
187 EPApp app = mockApp();
188 applicationList.add(app);
189 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
190 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
191 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey))).thenReturn(answer);
192 assertEquals(externalAccessRolesController.getRolesForApp(mockedRequest, mockedResponse), null);
195 @Test(expected = NullPointerException.class)
196 public void getRolesForAppExceptionTest() throws Exception {
197 List<EPApp> applicationList = new ArrayList<EPApp>();
198 EPApp app = mockApp();
199 applicationList.add(app);
200 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
201 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
202 externalAccessRolesController.getRolesForApp(mockedRequest,mockedResponse);
203 List<CentralV2Role> role = externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey));
204 assertEquals(null,role);
208 public void getRoleFunctionsListTest() throws Exception {
209 String reason = getInvalidKeyJson();
210 StringWriter sw = new StringWriter();
211 PrintWriter writer = new PrintWriter(sw);
212 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
213 List<CentralV2RoleFunction> answer = null;
214 Mockito.when(externalAccessRolesService.getRoleFuncList(mockedRequest.getHeader(uebKey))).thenReturn(null);
215 assertEquals(externalAccessRolesController.getRoleFunctionsList(mockedRequest, mockedResponse), answer);
216 String result = sw.getBuffer().toString().trim();
217 assertEquals(reason, result);
221 public void getRoleFunctionsListExceptionTest() throws Exception {
222 String reason = getInvalidKeyJson();
223 StringWriter sw = new StringWriter();
224 PrintWriter writer = new PrintWriter(sw);
225 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
226 externalAccessRolesController.getRoleFunctionsList(mockedRequest, mockedResponse);
227 String result = sw.getBuffer().toString().trim();
228 assertEquals(reason, result);
232 public void getRoleInfoTest() throws Exception {
233 String reason = getInvalidKeyJson();
234 StringWriter sw = new StringWriter();
235 PrintWriter writer = new PrintWriter(sw);
236 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
237 CentralV2Role answer = new CentralV2Role();
239 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader(uebKey)))
241 externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse, roleId);
242 String result = sw.getBuffer().toString().trim();
243 assertEquals(reason, result);
247 public void getRoleInfoExceptionTest() throws Exception {
248 String reason = getInvalidKeyJson();
249 StringWriter sw = new StringWriter();
250 PrintWriter writer = new PrintWriter(sw);
251 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
253 assertNull(externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse, roleId));
254 String result = sw.getBuffer().toString().trim();
255 assertEquals(reason, result);
259 public void getRoleFunctionTest() throws Exception {
260 EPApp mockApp = mockApp();
261 mockApp.setCentralAuth(true);
262 List<EPApp> mockAppList = new ArrayList<>();
263 mockAppList.add(mockApp);
264 StringWriter sw = new StringWriter();
265 PrintWriter writer = new PrintWriter(sw);
266 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
267 CentralV2RoleFunction roleFunction1 = new CentralV2RoleFunction();
268 CentralRoleFunction roleFunction2 = new CentralRoleFunction();
269 roleFunction1.setCode("test2");
270 String code = "test_menu";
271 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
272 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(mockAppList);
273 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
274 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(mockAppList.get(0))).thenReturn(response);
275 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader("uebkey")))
276 .thenReturn(roleFunction1);
277 CentralRoleFunction returnedValue = externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse, code);
278 assertEquals(returnedValue, roleFunction2);
279 String result = sw.getBuffer().toString().trim();
280 assertEquals("", result);
284 public void getRoleFunctionExceptionTest() throws Exception {
285 String reason = getInvalidKeyJson();
286 StringWriter sw = new StringWriter();
287 PrintWriter writer = new PrintWriter(sw);
288 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
289 String code = "test_menu";
290 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader(uebKey)))
291 .thenThrow(httpClientErrorException);
292 assertEquals(new CentralRoleFunction(),externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse, code));
293 String result = sw.getBuffer().toString().trim();
294 assertEquals(reason, result);
298 public void saveRoleFunctionIfIsNotDeletedTest() throws Exception {
299 List<EPApp> applicationList = new ArrayList<EPApp>();
300 EPApp app = mockApp();
301 applicationList.add(app);
302 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
303 PortalRestResponse<String> portalRestResponse = null;
304 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
305 expectedportalRestResponse.setMessage(null);
306 expectedportalRestResponse.setResponse("Failed");
307 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
309 CentralV2RoleFunction centralV2RoleFunction = new CentralV2RoleFunction();
310 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
311 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
312 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
313 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
314 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(centralV2RoleFunction, app)).thenReturn(false);
315 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, data);
316 assertEquals(portalRestResponse, expectedportalRestResponse);
320 public void saveRoleFunctionExceptionTest() throws Exception {
321 List<EPApp> applicationList = new ArrayList<EPApp>();
322 EPApp app = mockApp();
323 app.setCentralAuth(true);
324 applicationList.add(app);
325 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
326 PortalRestResponse<String> portalRestResponse = null;
327 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
328 expectedportalRestResponse.setMessage(null);
329 expectedportalRestResponse.setResponse("Failed");
330 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
331 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
332 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
333 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
334 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
335 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, null);
336 assertEquals(portalRestResponse, expectedportalRestResponse);
340 public void saveRoleFunctionTest() throws Exception {
341 List<EPApp> applicationList = new ArrayList<EPApp>();
342 EPUser user = mockUser.mockEPUser();
343 List<EPUser> userList = new ArrayList<>();
345 EPApp app = mockApp();
346 app.setCentralAuth(true);
347 applicationList.add(app);
348 JSONObject roleFunc = new JSONObject();
349 roleFunc.put("type", "test_type");
350 roleFunc.put("code", "test_instance");
351 roleFunc.put("action", "test_action");
352 roleFunc.put("name", "test_name");
353 ObjectMapper mapper = new ObjectMapper();
354 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
355 CentralV2RoleFunction saveRoleFunc = mapper.readValue(roleFunc.toString(), CentralV2RoleFunction.class);
356 saveRoleFunc.setAppId(app.getId());
357 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
358 PortalRestResponse<String> portalRestResponse = null;
359 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
360 expectedportalRestResponse.setMessage("Successfully saved!");
361 expectedportalRestResponse.setResponse("Success");
362 PortalRestStatusEnum portalRestStatusEnum = null;
363 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
364 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
365 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
366 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
367 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
368 Mockito.when(externalAccessRolesService.getRoleFunction("test_type|test_instance|test_action", app.getUebKey()))
370 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(Matchers.any(CentralV2RoleFunction.class),
371 Matchers.any(EPApp.class))).thenReturn(true);
372 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader(Matchers.anyString())))
373 .thenReturn(userList);
374 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(Matchers.anyString())))
375 .thenReturn(applicationList);
376 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse,
377 roleFunc.toString());
378 assertEquals(portalRestResponse, expectedportalRestResponse);
382 public void deleteRoleFunctionTest() throws Exception {
383 PowerMockito.mockStatic(EcompPortalUtils.class);
384 PowerMockito.mockStatic(SystemProperties.class);
385 PowerMockito.mockStatic(EPCommonSystemProperties.class);
386 PowerMockito.mockStatic(PortalConstants.class);
387 PortalRestResponse<String> portalRestResponse = null;
388 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
389 expectedportalRestResponse.setMessage("Successfully Deleted");
390 expectedportalRestResponse.setResponse("Success");
391 PortalRestStatusEnum portalRestStatusEnum = null;
392 EPUser user = mockUser.mockEPUser();
393 List<EPUser> userList = new ArrayList<>();
395 EPApp app = mockApp();
396 app.setCentralAuth(true);
397 List<EPApp> appList = new ArrayList<>();
399 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
400 String code ="testNew";
401 Mockito.when(mockedRequest.getHeader("LoginId")).thenReturn("guestT");
402 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
403 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
404 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
405 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
406 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
407 Mockito.when(externalAccessRolesService.deleteCentralRoleFunction(code, app)).thenReturn(true);
408 portalRestResponse = externalAccessRolesController.deleteRoleFunction(mockedRequest, mockedResponse, code);
409 assertEquals(portalRestResponse, expectedportalRestResponse);
413 public void getActiveRolesTest() throws Exception {
414 String reason = getInvalidKeyJson();
415 StringWriter sw = new StringWriter();
416 PrintWriter writer = new PrintWriter(sw);
417 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
418 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey))).thenReturn(null);
419 List<CentralRole> expectedCenRole = externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
420 assertNull(expectedCenRole);
421 String result = sw.getBuffer().toString().trim();
422 assertEquals(reason, result);
426 public void getActiveRolesExceptionTest() throws Exception {
427 String reason = getInvalidKeyJson();
428 StringWriter sw = new StringWriter();
429 PrintWriter writer = new PrintWriter(sw);
430 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
431 externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
432 String result = sw.getBuffer().toString().trim();
433 assertEquals(reason, result);
437 * It return JSON string which has error information
439 * @return JSON String
440 * @throws JsonProcessingException
442 private String getInvalidKeyJson() throws JsonProcessingException {
443 final Map<String,String> uebkeyResponse = new HashMap<>();
445 ObjectMapper mapper = new ObjectMapper();
446 uebkeyResponse.put("error","Invalid uebkey!");
447 reason = mapper.writeValueAsString(uebkeyResponse);
452 public void deleteDependcyRoleRecordExceptionTest() throws Exception {
453 PortalRestResponse<String> portalRestResponse = null;
454 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
455 expectedportalRestResponse.setMessage("Invalid uebkey!");
456 expectedportalRestResponse.setResponse("Failed");
457 PortalRestStatusEnum portalRestStatusEnum = null;
458 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
460 portalRestResponse = externalAccessRolesController.deleteDependencyRoleRecord(mockedRequest, mockedResponse, roleId);
461 assertEquals(expectedportalRestResponse, portalRestResponse);
465 public void bulkUploadFunctionsTest() throws Exception {
467 Mockito.when(externalAccessRolesService.bulkUploadFunctions(mockedRequest.getHeader(uebKey)))
469 PortalRestResponse<String> portalRestResponse = null;
470 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
471 expectedportalRestResponse.setMessage("Successfully added: 0");
472 expectedportalRestResponse.setResponse("Success");
473 PortalRestStatusEnum portalRestStatusEnum = null;
474 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
475 portalRestResponse = externalAccessRolesController.bulkUploadFunctions(mockedRequest, mockedResponse);
476 assertEquals(portalRestResponse, expectedportalRestResponse);
480 public void bulkUploadFunctionsExceptionTest() throws Exception {
481 Mockito.when(externalAccessRolesService.bulkUploadFunctions(mockedRequest.getHeader(uebKey)))
482 .thenThrow(httpClientErrorException);
483 PortalRestResponse<String> portalRestResponse = null;
484 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
485 expectedportalRestResponse.setMessage("Failed to bulkUploadFunctions");
486 expectedportalRestResponse.setResponse("Failed");
487 PortalRestStatusEnum portalRestStatusEnum = null;
488 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
489 portalRestResponse = externalAccessRolesController.bulkUploadFunctions(mockedRequest, mockedResponse);
490 assertEquals(portalRestResponse, expectedportalRestResponse);
494 public void bulkUploadRolesTest() throws Exception {
496 PortalRestResponse<String> portalRestResponse = null;
497 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
498 expectedportalRestResponse.setMessage("Successfully added: 0");
499 expectedportalRestResponse.setResponse("Success");
500 PortalRestStatusEnum portalRestStatusEnum = null;
501 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
502 Mockito.when(externalAccessRolesService.bulkUploadRoles(mockedRequest.getHeader(uebKey))).thenReturn(result);
503 portalRestResponse = externalAccessRolesController.bulkUploadRoles(mockedRequest, mockedResponse);
504 assertEquals(portalRestResponse, expectedportalRestResponse);
508 public void bulkUploadRolesTestException() throws Exception {
509 Mockito.when(externalAccessRolesService.bulkUploadRoles(mockedRequest.getHeader(uebKey)))
510 .thenThrow(httpClientErrorException);
511 PortalRestResponse<String> portalRestResponse = null;
512 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
513 expectedportalRestResponse.setMessage("Failed to bulkUploadRoles");
514 expectedportalRestResponse.setResponse("Failed");
515 PortalRestStatusEnum portalRestStatusEnum = null;
516 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
517 portalRestResponse = externalAccessRolesController.bulkUploadRoles(mockedRequest, mockedResponse);
518 assertEquals(portalRestResponse, expectedportalRestResponse);
522 public void bulkUploadRoleFunctionsTest() throws Exception {
524 PortalRestResponse<String> portalRestResponse = null;
525 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
526 expectedportalRestResponse.setMessage("Successfully added: 0");
527 expectedportalRestResponse.setResponse("Success");
528 PortalRestStatusEnum portalRestStatusEnum = null;
529 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
530 Mockito.when(externalAccessRolesService.bulkUploadRolesFunctions(mockedRequest.getHeader(uebKey)))
532 portalRestResponse = externalAccessRolesController.bulkUploadRoleFunctions(mockedRequest, mockedResponse);
533 assertEquals(portalRestResponse, expectedportalRestResponse);
537 public void bulkUploadRoleFunctionsException() throws Exception {
538 Mockito.when(externalAccessRolesService.bulkUploadRolesFunctions(mockedRequest.getHeader(uebKey)))
539 .thenThrow(httpClientErrorException);
540 PortalRestResponse<String> portalRestResponse = null;
541 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
542 expectedportalRestResponse.setMessage("Failed to bulkUploadRoleFunctions");
543 expectedportalRestResponse.setResponse("Failed");
544 PortalRestStatusEnum portalRestStatusEnum = null;
545 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
546 portalRestResponse = externalAccessRolesController.bulkUploadRoleFunctions(mockedRequest, mockedResponse);
547 assertEquals(portalRestResponse, expectedportalRestResponse);
551 public void bulkUploadUserRolesTest() throws Exception {
553 PortalRestResponse<String> portalRestResponse = null;
554 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
555 expectedportalRestResponse.setMessage("Successfully added: 0");
556 expectedportalRestResponse.setResponse("Success");
557 PortalRestStatusEnum portalRestStatusEnum = null;
558 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
559 Mockito.when(externalAccessRolesService.bulkUploadUserRoles(mockedRequest.getHeader(uebKey)))
561 portalRestResponse = externalAccessRolesController.bulkUploadUserRoles(mockedRequest, mockedResponse);
562 assertEquals(portalRestResponse, expectedportalRestResponse);
566 public void bulkUploadUserRolesExceptionTest() throws Exception {
567 Mockito.when(externalAccessRolesService.bulkUploadUserRoles(mockedRequest.getHeader(uebKey)))
568 .thenThrow(httpClientErrorException);
569 PortalRestResponse<String> portalRestResponse = null;
570 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
571 expectedportalRestResponse.setMessage("Failed to bulkUploadUserRoles");
572 expectedportalRestResponse.setResponse("Failed");
573 PortalRestStatusEnum portalRestStatusEnum = null;
574 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
575 portalRestResponse = externalAccessRolesController.bulkUploadUserRoles(mockedRequest, mockedResponse);
576 assertEquals(portalRestResponse, expectedportalRestResponse);
580 public void bulkUploadPartnerFunctionsTest() throws Exception {
581 PortalRestResponse<String> portalRestResponse = null;
582 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
583 expectedportalRestResponse.setMessage("Successfully added: '0' functions");
584 expectedportalRestResponse.setResponse("Success");
585 PortalRestStatusEnum portalRestStatusEnum = null;
586 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
587 portalRestResponse = externalAccessRolesController.bulkUploadPartnerFunctions(mockedRequest, mockedResponse);
588 assertEquals(portalRestResponse, expectedportalRestResponse);
593 public void bulkUploadPartnerRolesTest() throws Exception {
594 PortalRestResponse<String> portalRestResponse = null;
595 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
596 expectedportalRestResponse.setMessage("Successfully added");
597 expectedportalRestResponse.setResponse("Success");
598 PortalRestStatusEnum portalRestStatusEnum = null;
599 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
600 List<Role> upload = new ArrayList<>();
601 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoles(mockedRequest, mockedResponse,
603 assertEquals(portalRestResponse, expectedportalRestResponse);
607 public void bulkUploadPartnerRolesExceptionTest() throws Exception
609 ExternalAccessRolesService externalAccessRolesService = null;
610 PortalRestResponse<String> portalRestResponse = null;
611 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
612 expectedportalRestResponse.setMessage("Successfully added");
613 expectedportalRestResponse.setResponse("Success");
614 PortalRestStatusEnum portalRestStatusEnum = null;
615 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
616 List<Role> upload = new ArrayList<>();
617 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoles(mockedRequest, mockedResponse,
619 assertEquals(portalRestResponse, expectedportalRestResponse);
623 public void getMenuFunctionsTest() throws Exception {
624 String reason = getInvalidKeyJson();
625 StringWriter sw = new StringWriter();
626 PrintWriter writer = new PrintWriter(sw);
627 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
628 Mockito.when(externalAccessRolesService.getMenuFunctionsList(mockedRequest.getHeader(uebKey)))
630 List<String> expectedFunctionsList = externalAccessRolesController.getMenuFunctions(mockedRequest,
632 assertNull(expectedFunctionsList);
633 String result = sw.getBuffer().toString().trim();
634 assertEquals(reason, result);
638 public void getMenuFunctionsExceptionTest() throws Exception {
639 String reason = getInvalidKeyJson();
640 StringWriter sw = new StringWriter();
641 PrintWriter writer = new PrintWriter(sw);
642 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
643 Mockito.when(externalAccessRolesService.getMenuFunctionsList(mockedRequest.getHeader(uebKey)))
644 .thenThrow(httpClientErrorException);
645 assertNull(externalAccessRolesController.getMenuFunctions(mockedRequest, mockedResponse));
646 String result = sw.getBuffer().toString().trim();
647 assertEquals(reason, result);
652 public void saveRoleExceptionTest() throws Exception {
653 Role role = new Role();
654 PortalRestResponse<String> portalRestResponse = null;
655 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
656 expectedportalRestResponse.setMessage("Invalid uebkey!");
657 expectedportalRestResponse.setResponse("Failed");
658 PortalRestStatusEnum portalRestStatusEnum = null;
659 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
660 List<Role> upload = new ArrayList<>();
661 portalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse,role);
663 assertEquals(portalRestResponse, expectedportalRestResponse);
667 public void deleteRoleExceptionTest() throws Exception {
668 String role = "TestNew";
669 PortalRestResponse<String> portalRestResponse = null;
670 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
671 expectedportalRestResponse.setMessage("Invalid uebkey!");
672 expectedportalRestResponse.setResponse("Failed");
673 PortalRestStatusEnum portalRestStatusEnum = null;
674 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
675 portalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse,role);
676 assertEquals(portalRestResponse, expectedportalRestResponse);
681 public void bulkUploadPartnerRoleFunctionsTest() throws Exception {
682 PortalRestResponse<String> portalRestResponse = null;
683 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
684 expectedportalRestResponse.setMessage("Successfully added: '0' role functions");
685 expectedportalRestResponse.setResponse("Success");
686 PortalRestStatusEnum portalRestStatusEnum = null;
687 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
688 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoleFunctions(mockedRequest, mockedResponse);
689 assertEquals(portalRestResponse, expectedportalRestResponse);
693 public void getUsersOfApplicationTest() throws Exception
695 List<EcompUser> users = new ArrayList<>();
696 EcompUser user = new EcompUser();
697 user.setOrgUserId("guestT");
699 StringWriter sw = new StringWriter();
700 PrintWriter writer = new PrintWriter(sw);
701 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
702 List<EPApp> applicationList = new ArrayList<EPApp>();
703 EPApp app = mockApp();
704 app.setCentralAuth(true);
705 applicationList.add(app);
706 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
707 Mockito.when(externalAccessRolesService.getAllAppUsers(mockedRequest.getHeader(uebKey))).thenReturn(users);
708 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
709 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
710 List<EcompUser> expectedUsers = externalAccessRolesController.getUsersOfApplication(mockedRequest, mockedResponse);
711 assertEquals(expectedUsers, users);
714 @Test(expected = Exception.class)
715 public void getUsersOfApplicationExceptionTest() throws Exception
717 List<EcompUser> users = new ArrayList<>();
718 EcompUser user = new EcompUser();
719 user.setOrgUserId("guestT");
721 Mockito.when(externalAccessRolesService.getAllAppUsers(mockedRequest.getHeader(uebKey))).thenThrow(nullPointerException);
722 assertNull(externalAccessRolesController.getUsersOfApplication(mockedRequest, mockedResponse));
725 @Test(expected = NullPointerException.class)
726 public void deleteRoleV2Test() throws Exception
728 List<EPApp> applicationList = new ArrayList<EPApp>();
729 EPApp app = mockApp();
730 applicationList.add(app);
731 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
732 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(true, "Success");
733 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(),Matchers.anyString(),Matchers.anyString())).thenReturn(externalRequestFieldsValidator);
734 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
735 expectedportalRestResponse.setMessage("Successfully Deleted");
736 expectedportalRestResponse.setResponse("Success");
737 PortalRestStatusEnum portalRestStatusEnum = null;
738 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
739 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, (long)1);
740 assertNull(actualResponse);
744 public void deleteRoleV2InvalidUebKeyTest() throws Exception
746 List<EPApp> applicationList = new ArrayList<EPApp>();
747 EPApp app = mockApp();
748 applicationList.add(app);
749 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenThrow(new Exception("Invalid uebkey!"));
750 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
751 expectedportalRestResponse.setMessage("Invalid uebkey!");
752 expectedportalRestResponse.setResponse("Failed");
753 PortalRestStatusEnum portalRestStatusEnum = null;
754 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
755 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, (long)1);
756 assertEquals(actualResponse, expectedportalRestResponse);
760 public void deleteRoleV2InvalidUebKeyWithDiffErrorTest() throws Exception
762 List<EPApp> applicationList = new ArrayList<EPApp>();
763 EPApp app = mockApp();
764 applicationList.add(app);
765 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenThrow(new Exception("test"));
766 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
767 expectedportalRestResponse.setMessage("test");
768 expectedportalRestResponse.setResponse("Failed");
769 PortalRestStatusEnum portalRestStatusEnum = null;
770 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
771 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, (long)1);
772 assertEquals(actualResponse, expectedportalRestResponse);
776 @Test(expected = NullPointerException.class)
777 public void deleteRoleV2ExceptionTest() throws Exception
779 List<EPApp> applicationList = new ArrayList<EPApp>();
780 EPApp app = mockApp();
781 applicationList.add(app);
782 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
783 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false, "failed");
784 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(),Matchers.anyString(),Matchers.anyString())).thenReturn(externalRequestFieldsValidator);
785 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
786 expectedportalRestResponse.setMessage("Failed to deleteRole");
787 expectedportalRestResponse.setResponse("Failed");
788 PortalRestStatusEnum portalRestStatusEnum = null;
789 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
790 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, (long)1);
791 assertEquals(actualResponse, null);
795 public void getEpUserNullTest() throws Exception{
796 List<EPApp> applicationList = new ArrayList<EPApp>();
797 EPApp app = mockApp();
798 app.setUebKey("uebKey");
799 app.setCentralAuth(true);
800 applicationList.add(app);
801 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
802 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
803 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
804 assertNull(externalAccessRolesController.getEcompUser(mockedRequest, mockedResponse, "test12"));
808 public void getEpUserTest() 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 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\"}";
818 Mockito.when(externalAccessRolesService.getV2UserWithRoles("test12", mockedRequest.getHeader(uebKey))).thenReturn(user);
819 User EPuser = new User();
820 EPuser.setFirstName("test");
821 Mockito.when(userservice.userMapper(user)).thenReturn(EPuser);
822 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\":[]}";
823 assertEquals(externalAccessRolesController.getEcompUser(mockedRequest, mockedResponse, "test12"),res);
827 public void getEpUserExceptionTest() throws Exception{
828 List<EPApp> applicationList = new ArrayList<EPApp>();
829 EPApp app = mockApp();
830 app.setCentralAuth(true);
831 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
832 StringWriter sw = new StringWriter();
833 PrintWriter writer = new PrintWriter(sw);
834 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
835 assertNull(externalAccessRolesController.getEcompUser(mockedRequest, mockedResponse, "test12"));
839 public void getEPRolesOfApplicationTest() throws Exception
841 List<EPApp> applicationList = new ArrayList<EPApp>();
842 EPApp app = mockApp();
843 app.setUebKey("uebKey");
844 app.setCentralAuth(true);
845 applicationList.add(app);
846 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
847 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
848 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
849 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
850 List<CentralV2Role> cenRoleList = new ArrayList<>();
851 CentralV2Role role = new CentralV2Role();
852 role.setName("test");
853 cenRoleList.add(role);
854 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey))).thenReturn(cenRoleList);
855 List<EcompRole> ecompRoles = new ArrayList<>();
856 EcompRole eprole = new EcompRole();
857 eprole.setName("test");
858 ecompRoles.add(eprole);
859 assertEquals(ecompRoles,externalAccessRolesController.getEcompRolesOfApplication(mockedRequest, mockedResponse));
862 public void getEPRolesOfApplicationNullTest() throws Exception
864 List<EPApp> applicationList = new ArrayList<EPApp>();
865 EPApp app = mockApp();
866 app.setUebKey("uebKey");
867 app.setCentralAuth(true);
868 applicationList.add(app);
869 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
870 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
871 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
872 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
873 List<CentralV2Role> cenRoleList = new ArrayList<>();
874 CentralV2Role role = new CentralV2Role();
875 role.setName("test");
876 cenRoleList.add(role);
877 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey))).thenReturn(null);
878 assertNull(externalAccessRolesController.getEcompRolesOfApplication(mockedRequest, mockedResponse));
883 public void getEPRolesOfApplicationExceptionTest() throws Exception
885 List<EPApp> applicationList = new ArrayList<EPApp>();
886 EPApp app = mockApp();
887 app.setCentralAuth(true);
888 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
889 StringWriter sw = new StringWriter();
890 PrintWriter writer = new PrintWriter(sw);
891 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
892 assertNull(externalAccessRolesController.getEcompRolesOfApplication(mockedRequest, mockedResponse));