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============================================
36 * ECOMP is a trademark and service mark of AT&T Intellectual Property.
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.Ignore;
56 import org.junit.Test;
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.CentralRoleFunction;
72 import org.onap.portalapp.portal.transport.CentralV2Role;
73 import org.onap.portalapp.portal.transport.ExternalRequestFieldsValidator;
74 import org.onap.portalsdk.core.domain.AuditLog;
75 import org.onap.portalsdk.core.domain.Role;
76 import org.onap.portalsdk.core.restful.domain.EcompUser;
77 import org.springframework.beans.BeanUtils;
78 import org.springframework.http.HttpStatus;
79 import org.springframework.web.client.HttpClientErrorException;
81 import com.fasterxml.jackson.core.JsonProcessingException;
82 import com.fasterxml.jackson.databind.ObjectMapper;
84 public class ExternalAccessRolesControllerTest {
87 ExternalAccessRolesService externalAccessRolesService = new ExternalAccessRolesServiceImpl();
90 ExternalAccessRolesController externalAccessRolesController = new ExternalAccessRolesController();
94 MockitoAnnotations.initMocks(this);
97 AuditLog auditLog = new AuditLog();
99 MockitoTestSuite mockitoTestSuite = new MockitoTestSuite();
101 HttpServletRequest mockedRequest = mockitoTestSuite.getMockedRequest();
102 HttpServletResponse mockedResponse = mockitoTestSuite.getMockedResponse();
103 NullPointerException nullPointerException = new NullPointerException();
104 HttpClientErrorException httpClientErrorException = new HttpClientErrorException(HttpStatus.BAD_REQUEST, "Failed");
106 MockEPUser mockUser = new MockEPUser();
107 String loginId = "guestT";
108 String uebKey = "testUebKey";
111 public void getUserTest() throws Exception {
112 String reason = getInvalidKeyJson();
113 StringWriter sw = new StringWriter();
114 PrintWriter writer = new PrintWriter(sw);
115 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
116 List<EPUser> userList = new ArrayList<>();
117 Mockito.when(externalAccessRolesService.getUser(loginId)).thenReturn(userList);
118 externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId);
119 String result = sw.getBuffer().toString().trim();
120 assertEquals(reason, result);
124 public void getUserExceptionTest() throws Exception {
125 String reason = getInvalidKeyJson();
126 StringWriter sw = new StringWriter();
127 PrintWriter writer = new PrintWriter(sw);
128 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
129 externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId);
130 String result = sw.getBuffer().toString().trim();
131 assertEquals(reason, result);
134 public EPApp mockApp()
136 EPApp app = new EPApp();
138 app.setImageUrl("test");
139 app.setDescription("test");
140 app.setNotes("test");
143 app.setAppRestEndpoint("test");
144 app.setAlternateUrl("test");
146 app.setMlAppName("test");
147 app.setMlAppAdminId("test");
148 app.setUsername("test");
149 app.setAppPassword("test");
151 app.setEnabled(false);
152 app.setUebKey("test");
153 app.setUebSecret("test");
154 app.setUebTopicName("test");
159 @Test(expected = NullPointerException.class)
160 public void getRolesForAppTest() throws Exception {
161 List<EPApp> applicationList = new ArrayList<EPApp>();
162 List<CentralV2Role> answer = new ArrayList<>();
163 EPApp app = mockApp();
164 applicationList.add(app);
165 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
166 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
167 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey))).thenReturn(answer);
168 assertEquals(externalAccessRolesController.getRolesForApp(mockedRequest, mockedResponse), null);
171 @Test(expected = NullPointerException.class)
172 public void getRolesForAppExceptionTest() throws Exception {
173 List<EPApp> applicationList = new ArrayList<EPApp>();
174 EPApp app = mockApp();
175 applicationList.add(app);
176 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
177 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
178 externalAccessRolesController.getRolesForApp(mockedRequest,mockedResponse);
179 List<CentralV2Role> role = externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey));
180 assertEquals(null,role);
184 public void getRoleFunctionsListTest() throws Exception {
185 String reason = getInvalidKeyJson();
186 StringWriter sw = new StringWriter();
187 PrintWriter writer = new PrintWriter(sw);
188 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
189 List<CentralV2RoleFunction> answer = null;
190 Mockito.when(externalAccessRolesService.getRoleFuncList(mockedRequest.getHeader(uebKey))).thenReturn(null);
191 assertEquals(externalAccessRolesController.getRoleFunctionsList(mockedRequest, mockedResponse), answer);
192 String result = sw.getBuffer().toString().trim();
193 assertEquals(reason, result);
197 public void getRoleFunctionsListExceptionTest() throws Exception {
198 String reason = getInvalidKeyJson();
199 StringWriter sw = new StringWriter();
200 PrintWriter writer = new PrintWriter(sw);
201 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
202 externalAccessRolesController.getRoleFunctionsList(mockedRequest, mockedResponse);
203 String result = sw.getBuffer().toString().trim();
204 assertEquals(reason, result);
208 public void getRoleInfoTest() 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 CentralV2Role answer = new CentralV2Role();
215 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader(uebKey)))
217 externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse, roleId);
218 String result = sw.getBuffer().toString().trim();
219 assertEquals(reason, result);
223 public void getRoleInfoExceptionTest() throws Exception {
224 String reason = getInvalidKeyJson();
225 StringWriter sw = new StringWriter();
226 PrintWriter writer = new PrintWriter(sw);
227 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
229 assertNull(externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse, roleId));
230 String result = sw.getBuffer().toString().trim();
231 assertEquals(reason, result);
235 public void getRoleFunctionTest() throws Exception {
236 String reason = getInvalidKeyJson();
237 StringWriter sw = new StringWriter();
238 PrintWriter writer = new PrintWriter(sw);
239 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
240 CentralV2RoleFunction centralV2RoleFunction = new CentralV2RoleFunction();
241 CentralRoleFunction centralRoleFunction = new CentralRoleFunction();
242 String code = "test_menu";
243 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader(uebKey)))
244 .thenReturn(centralV2RoleFunction);
245 CentralRoleFunction returnedValue = externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse, code);
246 BeanUtils.copyProperties(centralV2RoleFunction, centralRoleFunction, "type","action");
247 assertEquals(returnedValue,centralRoleFunction);
248 String result = sw.getBuffer().toString().trim();
249 assertEquals(reason, result);
253 public void getRoleFunctionExceptionTest() throws Exception {
254 String reason = getInvalidKeyJson();
255 StringWriter sw = new StringWriter();
256 PrintWriter writer = new PrintWriter(sw);
257 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
258 String code = "test_menu";
259 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader(uebKey)))
260 .thenThrow(httpClientErrorException);
261 assertEquals(new CentralRoleFunction(),externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse, code));
262 String result = sw.getBuffer().toString().trim();
263 assertEquals(reason, result);
266 @Test(expected = NullPointerException.class)
267 public void saveRoleFunctionIfIsIsNotDeletedTest() throws Exception {
268 List<EPApp> applicationList = new ArrayList<EPApp>();
269 EPApp app = mockApp();
270 applicationList.add(app);
271 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
272 PortalRestResponse<String> portalRestResponse = null;
273 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
274 expectedportalRestResponse.setMessage("Invalid uebkey!");
275 expectedportalRestResponse.setResponse("Failed");
276 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
278 CentralV2RoleFunction centralV2RoleFunction = new CentralV2RoleFunction();
279 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(centralV2RoleFunction, app)).thenReturn(false);
280 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, data);
281 assertEquals(portalRestResponse, expectedportalRestResponse);
284 @Test(expected = NullPointerException.class)
285 public void saveRoleFunctionExceptionTest() throws Exception {
286 List<EPApp> applicationList = new ArrayList<EPApp>();
287 EPApp app = mockApp();
288 applicationList.add(app);
289 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
290 PortalRestResponse<String> portalRestResponse = null;
291 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
292 expectedportalRestResponse.setMessage("Invalid uebkey!");
293 expectedportalRestResponse.setResponse("Failed");
294 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
295 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, null);
296 System.out.println(portalRestResponse);
297 assertEquals(portalRestResponse, expectedportalRestResponse);
300 @Test(expected = NullPointerException.class)
301 public void saveRoleFunctionTest() throws Exception {
302 List<EPApp> applicationList = new ArrayList<EPApp>();
303 EPApp app = mockApp();
304 applicationList.add(app);
305 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
306 PortalRestResponse<String> portalRestResponse = null;
307 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
308 expectedportalRestResponse.setMessage(null);
309 expectedportalRestResponse.setResponse("Failed");
310 PortalRestStatusEnum portalRestStatusEnum = null;
311 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
313 CentralV2RoleFunction centralV2RoleFunction = new CentralV2RoleFunction();
314 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(centralV2RoleFunction, app)).thenReturn(true);
315 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, data);
316 System.out.println(portalRestResponse);
317 assertEquals(portalRestResponse, expectedportalRestResponse);
322 public void deleteRoleFunctionTest() throws Exception {
323 PortalRestResponse<String> portalRestResponse = null;
324 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
325 expectedportalRestResponse.setMessage("Successfully Deleted");
326 expectedportalRestResponse.setResponse("Success");
327 PortalRestStatusEnum portalRestStatusEnum = null;
328 EPUser user = mockUser.mockEPUser();
329 EPApp app = mockApp();
330 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
331 String code ="testNew";
332 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LOGIN_ID"))).thenReturn((List<EPUser>) user);
333 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("UEBKEY")).get(0)).thenReturn(app);
334 Mockito.when(externalAccessRolesService.deleteCentralRoleFunction(code, app)).thenReturn(true);
335 portalRestResponse = externalAccessRolesController.deleteRoleFunction(mockedRequest, mockedResponse, code);
336 assertEquals(portalRestResponse, expectedportalRestResponse);
340 public void getActiveRolesTest() throws Exception {
341 String reason = getInvalidKeyJson();
342 StringWriter sw = new StringWriter();
343 PrintWriter writer = new PrintWriter(sw);
344 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
345 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey))).thenReturn(null);
346 List<CentralV2Role> expectedCenRole = externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
347 assertNull(expectedCenRole);
348 String result = sw.getBuffer().toString().trim();
349 assertEquals(reason, result);
353 public void getActiveRolesExceptionTest() throws Exception {
354 String reason = getInvalidKeyJson();
355 StringWriter sw = new StringWriter();
356 PrintWriter writer = new PrintWriter(sw);
357 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
358 externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
359 String result = sw.getBuffer().toString().trim();
360 assertEquals(reason, result);
364 * It return JSON string which has error information
366 * @return JSON String
367 * @throws JsonProcessingException
369 private String getInvalidKeyJson() throws JsonProcessingException {
370 final Map<String,String> uebkeyResponse = new HashMap<>();
372 ObjectMapper mapper = new ObjectMapper();
373 uebkeyResponse.put("error","Invalid uebkey!");
374 reason = mapper.writeValueAsString(uebkeyResponse);
379 public void deleteDependcyRoleRecordExceptionTest() throws Exception {
380 PortalRestResponse<String> portalRestResponse = null;
381 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
382 expectedportalRestResponse.setMessage("Invalid uebkey!");
383 expectedportalRestResponse.setResponse("Failed");
384 PortalRestStatusEnum portalRestStatusEnum = null;
385 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
387 portalRestResponse = externalAccessRolesController.deleteDependencyRoleRecord(mockedRequest, mockedResponse, roleId);
388 assertEquals(expectedportalRestResponse, portalRestResponse);
392 public void bulkUploadFunctionsTest() throws Exception {
394 Mockito.when(externalAccessRolesService.bulkUploadFunctions(mockedRequest.getHeader(uebKey)))
396 PortalRestResponse<String> portalRestResponse = null;
397 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
398 expectedportalRestResponse.setMessage("Successfully added: 0");
399 expectedportalRestResponse.setResponse("Success");
400 PortalRestStatusEnum portalRestStatusEnum = null;
401 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
402 portalRestResponse = externalAccessRolesController.bulkUploadFunctions(mockedRequest, mockedResponse);
403 assertEquals(portalRestResponse, expectedportalRestResponse);
407 public void bulkUploadFunctionsExceptionTest() throws Exception {
408 Mockito.when(externalAccessRolesService.bulkUploadFunctions(mockedRequest.getHeader(uebKey)))
409 .thenThrow(httpClientErrorException);
410 PortalRestResponse<String> portalRestResponse = null;
411 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
412 expectedportalRestResponse.setMessage("Failed to bulkUploadFunctions");
413 expectedportalRestResponse.setResponse("Failed");
414 PortalRestStatusEnum portalRestStatusEnum = null;
415 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
416 portalRestResponse = externalAccessRolesController.bulkUploadFunctions(mockedRequest, mockedResponse);
417 assertEquals(portalRestResponse, expectedportalRestResponse);
421 public void bulkUploadRolesTest() throws Exception {
423 PortalRestResponse<String> portalRestResponse = null;
424 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
425 expectedportalRestResponse.setMessage("Successfully added: 0");
426 expectedportalRestResponse.setResponse("Success");
427 PortalRestStatusEnum portalRestStatusEnum = null;
428 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
429 Mockito.when(externalAccessRolesService.bulkUploadRoles(mockedRequest.getHeader(uebKey))).thenReturn(result);
430 portalRestResponse = externalAccessRolesController.bulkUploadRoles(mockedRequest, mockedResponse);
431 assertEquals(portalRestResponse, expectedportalRestResponse);
435 public void bulkUploadRolesTestException() throws Exception {
436 Mockito.when(externalAccessRolesService.bulkUploadRoles(mockedRequest.getHeader(uebKey)))
437 .thenThrow(httpClientErrorException);
438 PortalRestResponse<String> portalRestResponse = null;
439 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
440 expectedportalRestResponse.setMessage("Failed to bulkUploadRoles");
441 expectedportalRestResponse.setResponse("Failed");
442 PortalRestStatusEnum portalRestStatusEnum = null;
443 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
444 portalRestResponse = externalAccessRolesController.bulkUploadRoles(mockedRequest, mockedResponse);
445 assertEquals(portalRestResponse, expectedportalRestResponse);
449 public void bulkUploadRoleFunctionsTest() throws Exception {
451 PortalRestResponse<String> portalRestResponse = null;
452 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
453 expectedportalRestResponse.setMessage("Successfully added: 0");
454 expectedportalRestResponse.setResponse("Success");
455 PortalRestStatusEnum portalRestStatusEnum = null;
456 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
457 Mockito.when(externalAccessRolesService.bulkUploadRolesFunctions(mockedRequest.getHeader(uebKey)))
459 portalRestResponse = externalAccessRolesController.bulkUploadRoleFunctions(mockedRequest, mockedResponse);
460 assertEquals(portalRestResponse, expectedportalRestResponse);
464 public void bulkUploadRoleFunctionsException() throws Exception {
465 Mockito.when(externalAccessRolesService.bulkUploadRolesFunctions(mockedRequest.getHeader(uebKey)))
466 .thenThrow(httpClientErrorException);
467 PortalRestResponse<String> portalRestResponse = null;
468 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
469 expectedportalRestResponse.setMessage("Failed to bulkUploadRoleFunctions");
470 expectedportalRestResponse.setResponse("Failed");
471 PortalRestStatusEnum portalRestStatusEnum = null;
472 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
473 portalRestResponse = externalAccessRolesController.bulkUploadRoleFunctions(mockedRequest, mockedResponse);
474 assertEquals(portalRestResponse, expectedportalRestResponse);
478 public void bulkUploadUserRolesTest() throws Exception {
480 PortalRestResponse<String> portalRestResponse = null;
481 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
482 expectedportalRestResponse.setMessage("Successfully added: 0");
483 expectedportalRestResponse.setResponse("Success");
484 PortalRestStatusEnum portalRestStatusEnum = null;
485 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
486 Mockito.when(externalAccessRolesService.bulkUploadUserRoles(mockedRequest.getHeader(uebKey)))
488 portalRestResponse = externalAccessRolesController.bulkUploadUserRoles(mockedRequest, mockedResponse);
489 assertEquals(portalRestResponse, expectedportalRestResponse);
493 public void bulkUploadUserRolesExceptionTest() throws Exception {
494 Mockito.when(externalAccessRolesService.bulkUploadUserRoles(mockedRequest.getHeader(uebKey)))
495 .thenThrow(httpClientErrorException);
496 PortalRestResponse<String> portalRestResponse = null;
497 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
498 expectedportalRestResponse.setMessage("Failed to bulkUploadUserRoles");
499 expectedportalRestResponse.setResponse("Failed");
500 PortalRestStatusEnum portalRestStatusEnum = null;
501 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
502 portalRestResponse = externalAccessRolesController.bulkUploadUserRoles(mockedRequest, mockedResponse);
503 assertEquals(portalRestResponse, expectedportalRestResponse);
507 public void bulkUploadPartnerFunctionsTest() throws Exception {
508 PortalRestResponse<String> portalRestResponse = null;
509 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
510 expectedportalRestResponse.setMessage("Successfully added");
511 expectedportalRestResponse.setResponse("Success");
512 PortalRestStatusEnum portalRestStatusEnum = null;
513 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
514 portalRestResponse = externalAccessRolesController.bulkUploadPartnerFunctions(mockedRequest, mockedResponse, null);
515 assertEquals(portalRestResponse, expectedportalRestResponse);
520 public void bulkUploadPartnerRolesTest() throws Exception {
521 PortalRestResponse<String> portalRestResponse = null;
522 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
523 expectedportalRestResponse.setMessage("Successfully added");
524 expectedportalRestResponse.setResponse("Success");
525 PortalRestStatusEnum portalRestStatusEnum = null;
526 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
527 List<Role> upload = new ArrayList<>();
528 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoles(mockedRequest, mockedResponse,
530 assertEquals(portalRestResponse, expectedportalRestResponse);
534 public void bulkUploadPartnerRolesExceptionTest() throws Exception
536 ExternalAccessRolesService externalAccessRolesService = null;
537 PortalRestResponse<String> portalRestResponse = null;
538 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
539 expectedportalRestResponse.setMessage("Successfully added");
540 expectedportalRestResponse.setResponse("Success");
541 PortalRestStatusEnum portalRestStatusEnum = null;
542 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
543 List<Role> upload = new ArrayList<>();
544 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoles(mockedRequest, mockedResponse,
546 assertEquals(portalRestResponse, expectedportalRestResponse);
550 public void getMenuFunctionsTest() throws Exception {
551 String reason = getInvalidKeyJson();
552 StringWriter sw = new StringWriter();
553 PrintWriter writer = new PrintWriter(sw);
554 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
555 Mockito.when(externalAccessRolesService.getMenuFunctionsList(mockedRequest.getHeader(uebKey)))
557 List<String> expectedFunctionsList = externalAccessRolesController.getMenuFunctions(mockedRequest,
559 assertNull(expectedFunctionsList);
560 String result = sw.getBuffer().toString().trim();
561 assertEquals(reason, result);
565 public void getMenuFunctionsExceptionTest() throws Exception {
566 String reason = getInvalidKeyJson();
567 StringWriter sw = new StringWriter();
568 PrintWriter writer = new PrintWriter(sw);
569 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
570 Mockito.when(externalAccessRolesService.getMenuFunctionsList(mockedRequest.getHeader(uebKey)))
571 .thenThrow(httpClientErrorException);
572 assertNull(externalAccessRolesController.getMenuFunctions(mockedRequest, mockedResponse));
573 String result = sw.getBuffer().toString().trim();
574 assertEquals(reason, result);
579 public void saveRoleExceptionTest() throws Exception {
580 Role role = new Role();
581 PortalRestResponse<String> portalRestResponse = null;
582 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
583 expectedportalRestResponse.setMessage("Invalid uebkey!");
584 expectedportalRestResponse.setResponse("Failed");
585 PortalRestStatusEnum portalRestStatusEnum = null;
586 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
587 List<Role> upload = new ArrayList<>();
588 portalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse,role);
590 assertEquals(portalRestResponse, expectedportalRestResponse);
594 public void deleteRoleExceptionTest() throws Exception {
595 String role = "TestNew";
596 PortalRestResponse<String> portalRestResponse = null;
597 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
598 expectedportalRestResponse.setMessage("Invalid uebkey!");
599 expectedportalRestResponse.setResponse("Failed");
600 PortalRestStatusEnum portalRestStatusEnum = null;
601 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
602 portalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse,role);
603 assertEquals(portalRestResponse, expectedportalRestResponse);
608 public void bulkUploadPartnerRoleFunctionsTest() throws Exception {
609 PortalRestResponse<String> portalRestResponse = null;
610 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
611 expectedportalRestResponse.setMessage("Successfully added");
612 expectedportalRestResponse.setResponse("Success");
613 PortalRestStatusEnum portalRestStatusEnum = null;
614 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
615 List<Role> upload = new ArrayList<>();
616 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoleFunctions(mockedRequest, mockedResponse,upload);
617 assertEquals(portalRestResponse, expectedportalRestResponse);
621 public void getUsersOfApplicationTest() throws Exception
623 List<EcompUser> users = new ArrayList<>();
624 EcompUser user = new EcompUser();
625 user.setOrgUserId("guestT");
627 Mockito.when(externalAccessRolesService.getAllAppUsers(mockedRequest.getHeader(uebKey))).thenReturn(users);
628 List<EcompUser> expectedUsers = externalAccessRolesController.getUsersOfApplication(mockedRequest, mockedResponse);
629 assertEquals(expectedUsers, users);
632 @Test(expected = Exception.class)
633 public void getUsersOfApplicationExceptionTest() throws Exception
635 List<EcompUser> users = new ArrayList<>();
636 EcompUser user = new EcompUser();
637 user.setOrgUserId("guestT");
639 Mockito.when(externalAccessRolesService.getAllAppUsers(mockedRequest.getHeader(uebKey))).thenThrow(nullPointerException);
640 assertNull(externalAccessRolesController.getUsersOfApplication(mockedRequest, mockedResponse));
643 @Test(expected = NullPointerException.class)
644 public void deleteRoleV2Test() throws Exception
646 List<EPApp> applicationList = new ArrayList<EPApp>();
647 EPApp app = mockApp();
648 applicationList.add(app);
649 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
650 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(true, "Success");
651 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(),Matchers.anyString(),Matchers.anyString())).thenReturn(externalRequestFieldsValidator);
652 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
653 expectedportalRestResponse.setMessage("Successfully Deleted");
654 expectedportalRestResponse.setResponse("Success");
655 PortalRestStatusEnum portalRestStatusEnum = null;
656 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
657 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, (long)1);
658 assertNull(actualResponse);
662 public void deleteRoleV2InvalidUebKeyTest() throws Exception
664 List<EPApp> applicationList = new ArrayList<EPApp>();
665 EPApp app = mockApp();
666 applicationList.add(app);
667 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenThrow(new Exception("Invalid uebkey!"));
668 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
669 expectedportalRestResponse.setMessage("Invalid uebkey!");
670 expectedportalRestResponse.setResponse("Failed");
671 PortalRestStatusEnum portalRestStatusEnum = null;
672 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
673 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, (long)1);
674 assertEquals(actualResponse, expectedportalRestResponse);
678 public void deleteRoleV2InvalidUebKeyWithDiffErrorTest() throws Exception
680 List<EPApp> applicationList = new ArrayList<EPApp>();
681 EPApp app = mockApp();
682 applicationList.add(app);
683 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenThrow(new Exception("test"));
684 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
685 expectedportalRestResponse.setMessage("test");
686 expectedportalRestResponse.setResponse("Failed");
687 PortalRestStatusEnum portalRestStatusEnum = null;
688 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
689 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, (long)1);
690 assertEquals(actualResponse, expectedportalRestResponse);
694 @Test(expected = NullPointerException.class)
695 public void deleteRoleV2ExceptionTest() throws Exception
697 List<EPApp> applicationList = new ArrayList<EPApp>();
698 EPApp app = mockApp();
699 applicationList.add(app);
700 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
701 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false, "failed");
702 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(),Matchers.anyString(),Matchers.anyString())).thenReturn(externalRequestFieldsValidator);
703 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
704 expectedportalRestResponse.setMessage("Failed to deleteRole");
705 expectedportalRestResponse.setResponse("Failed");
706 PortalRestStatusEnum portalRestStatusEnum = null;
707 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
708 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, (long)1);
709 assertEquals(actualResponse, null);