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;
40 import static org.junit.Assert.assertEquals;
41 import static org.junit.Assert.assertNull;
42 import static org.junit.Assert.assertTrue;
44 import java.io.IOException;
45 import java.io.PrintWriter;
46 import java.util.ArrayList;
47 import java.util.List;
49 import javax.servlet.http.HttpServletRequest;
50 import javax.servlet.http.HttpServletResponse;
51 import javax.servlet.http.HttpSession;
53 import org.junit.Before;
54 import org.junit.Test;
55 import org.junit.runner.RunWith;
56 import org.mockito.InjectMocks;
57 import org.mockito.Mock;
58 import org.mockito.Mockito;
59 import org.mockito.MockitoAnnotations;
60 import org.onap.portalapp.portal.core.MockEPUser;
61 import org.onap.portalapp.portal.domain.EPUser;
62 import org.onap.portalapp.portal.ecomp.model.PortalRestResponse;
63 import org.onap.portalapp.portal.ecomp.model.PortalRestStatusEnum;
64 import org.onap.portalapp.portal.framework.MockitoTestSuite;
65 import org.onap.portalapp.portal.service.AdminRolesService;
66 import org.onap.portalapp.portal.service.AdminRolesServiceImpl;
67 import org.onap.portalapp.portal.service.FunctionalMenuService;
68 import org.onap.portalapp.portal.service.FunctionalMenuServiceImpl;
69 import org.onap.portalapp.portal.service.SearchService;
70 import org.onap.portalapp.portal.transport.BusinessCardApplicationRole;
71 import org.onap.portalapp.portal.transport.BusinessCardApplicationRolesList;
72 import org.onap.portalapp.portal.transport.FavoritesFunctionalMenuItem;
73 import org.onap.portalapp.portal.transport.FavoritesFunctionalMenuItemJson;
74 import org.onap.portalapp.portal.transport.FieldsValidator;
75 import org.onap.portalapp.portal.transport.FieldsValidator.FieldName;
76 import org.onap.portalapp.portal.transport.FunctionalMenuItem;
77 import org.onap.portalapp.portal.transport.FunctionalMenuItemWithRoles;
78 import org.onap.portalapp.util.EPUserUtils;
79 import org.onap.portalsdk.core.domain.User;
80 import org.onap.portalsdk.core.service.DataAccessService;
81 import org.onap.portalsdk.core.util.SystemProperties;
82 import org.onap.portalsdk.core.web.support.UserUtils;
83 import org.powermock.api.mockito.PowerMockito;
84 import org.powermock.core.classloader.annotations.PrepareForTest;
85 import org.powermock.modules.junit4.PowerMockRunner;
87 @RunWith(PowerMockRunner.class)
88 @PrepareForTest(SystemProperties.class)
89 public class FunctionalMenuControllerTest extends MockitoTestSuite {
91 String userid = "ab1234";
94 FunctionalMenuService functionalMenuService = new FunctionalMenuServiceImpl();
97 FunctionalMenuController functionalMenuController = new FunctionalMenuController();
100 private DataAccessService dataAccessService;
103 SearchService searchService;
106 AdminRolesService adminRolesService = new AdminRolesServiceImpl();
108 NullPointerException nullPointerException = new NullPointerException();
111 public void setup() {
112 MockitoAnnotations.initMocks(this);
115 MockitoTestSuite mockitoTestSuite = new MockitoTestSuite();
117 HttpServletRequest mockedRequest = mockitoTestSuite.getMockedRequest();
118 HttpServletResponse mockedResponse = mockitoTestSuite.getMockedResponse();
121 EPUserUtils ePUserUtils = new EPUserUtils();
126 MockEPUser mockUser = new MockEPUser();
128 List<BusinessCardApplicationRolesList> appRoles = new ArrayList<BusinessCardApplicationRolesList>();
129 List<BusinessCardApplicationRolesList> appRolesActual = new ArrayList<BusinessCardApplicationRolesList>();
131 List<BusinessCardApplicationRole> userAppRoleList = new ArrayList<BusinessCardApplicationRole>();
133 public List<BusinessCardApplicationRole> mockBusinessCardApplicationRole() {
134 List<BusinessCardApplicationRole> userAppRoleList = new ArrayList<BusinessCardApplicationRole>();
136 BusinessCardApplicationRole businessCardApplicationRole = new BusinessCardApplicationRole();
137 businessCardApplicationRole.setRoleName("ADMIN");
138 businessCardApplicationRole.setAppName("ASDC");
140 BusinessCardApplicationRole businessCardApplicationRole1 = new BusinessCardApplicationRole();
141 businessCardApplicationRole1.setAppName("ASDC");
142 businessCardApplicationRole1.setRoleName("Tester");
144 userAppRoleList.add(businessCardApplicationRole);
145 userAppRoleList.add(businessCardApplicationRole1);
146 return userAppRoleList;
149 public List<BusinessCardApplicationRolesList> mockBusinessCardApplicationRolesList() {
150 List<BusinessCardApplicationRolesList> appRolesActual = new ArrayList<BusinessCardApplicationRolesList>();
152 BusinessCardApplicationRolesList businessCardApplicationRolesList = new BusinessCardApplicationRolesList();
153 businessCardApplicationRolesList.setAppName("ASDC");
155 List<String> roleNames = new ArrayList<String>();
156 roleNames.add("ADMIN");
157 roleNames.add("Tester");
158 businessCardApplicationRolesList.setRoleNames(roleNames);
160 appRolesActual.add(businessCardApplicationRolesList);
161 return appRolesActual;
165 public void getAppListTestIfAppAlredyExistsBusinessCardApplicationRolesList() throws IOException {
167 userAppRoleList = mockBusinessCardApplicationRole();
168 appRolesActual = mockBusinessCardApplicationRolesList();
170 Mockito.when(functionalMenuService.getUserAppRolesList(userid)).thenReturn(userAppRoleList);
171 User user = new User();
172 user.setOrgUserId(userid);
173 Mockito.when(UserUtils.getUserSession(mockedRequest)).thenReturn(user);
175 appRoles = functionalMenuController.getAppList(mockedRequest, mockedResponse, userid);
177 assertEquals(appRolesActual.size(), appRoles.size());
178 assertEquals(appRolesActual.get(0).getAppName(), appRoles.get(0).getAppName());
179 assertEquals(appRolesActual.get(0).getRoleNames(), appRoles.get(0).getRoleNames());
184 public void getAppListTestForOtherUser() throws IOException {
186 userAppRoleList = mockBusinessCardApplicationRole();
187 appRolesActual = mockBusinessCardApplicationRolesList();
189 Mockito.when(functionalMenuService.getUserAppRolesList(userid)).thenReturn(userAppRoleList);
190 User user = new User();
191 user.setOrgUserId(userid + "other");
192 Mockito.when(UserUtils.getUserSession(mockedRequest)).thenReturn(user);
193 Mockito.when(mockedResponse.getWriter()).thenReturn(new PrintWriter(System.out));
195 appRoles = functionalMenuController.getAppList(mockedRequest, mockedResponse, userid);
196 assertNull(appRoles);
197 assertEquals(0, mockedResponse.getStatus());
203 public void editFunctionalMenuItemXSSTest(){
204 FunctionalMenuItemWithRoles menuItemJson = new FunctionalMenuItemWithRoles();
205 menuItemJson.url = "1<b>tes<img src=‘~‘ onerror=prompt(32)>t_menu";
206 FieldsValidator actualFieldsValidator = new FieldsValidator();
207 FieldsValidator expectedFieldsValidator = new FieldsValidator();
208 List<FieldName> fields = new ArrayList<>();
209 expectedFieldsValidator.setHttpStatusCode(406L);
210 expectedFieldsValidator.setFields(fields);
211 expectedFieldsValidator.setErrorCode(null);
212 EPUser user = mockUser.mockEPUser();
213 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
214 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
215 Mockito.when(functionalMenuService.editFunctionalMenuItem(menuItemJson)).thenReturn(actualFieldsValidator);
216 actualFieldsValidator = functionalMenuController.editFunctionalMenuItem(mockedRequest, menuItemJson, mockedResponse);
217 assertEquals(actualFieldsValidator, expectedFieldsValidator);
221 public void getAppListTestIfAppDoesnotExistsInBusinessCardApplicationRolesList() throws IOException {
223 userAppRoleList = mockBusinessCardApplicationRole();
224 BusinessCardApplicationRole businessCardApplicationRole = new BusinessCardApplicationRole();
225 businessCardApplicationRole.setAppName("CCD");
226 businessCardApplicationRole.setRoleName("ADMIN");
227 userAppRoleList.add(businessCardApplicationRole);
228 appRolesActual = mockBusinessCardApplicationRolesList();
229 BusinessCardApplicationRolesList businessCardApplicationRolesList = new BusinessCardApplicationRolesList();
230 businessCardApplicationRolesList.setAppName("CCD");
231 List<String> roleNames1 = new ArrayList<String>();
232 roleNames1.add("ADMIN");
233 businessCardApplicationRolesList.setRoleNames(roleNames1);
234 appRolesActual.add(businessCardApplicationRolesList);
235 Mockito.when(functionalMenuService.getUserAppRolesList(userid)).thenReturn(userAppRoleList);
236 User user = new User();
237 user.setOrgUserId(userid);
238 Mockito.when(UserUtils.getUserSession(mockedRequest)).thenReturn(user);
239 appRoles = functionalMenuController.getAppList(mockedRequest, mockedResponse, userid);
240 assertEquals(appRolesActual.size(), appRoles.size());
241 assertEquals(appRolesActual.get(0).getAppName(), appRoles.get(0).getAppName());
242 assertEquals(appRolesActual.get(0).getRoleNames(), appRoles.get(0).getRoleNames());
243 assertEquals(appRolesActual.get(1).getAppName(), appRoles.get(1).getAppName());
244 assertEquals(appRolesActual.get(1).getRoleNames(), appRoles.get(1).getRoleNames());
249 public void regenerateAncestorTableTest() {
250 EPUser user = mockUser.mockEPUser();
252 HttpSession session = mockedRequest.getSession();
253 session.setAttribute(SystemProperties.getProperty(SystemProperties.USER_ATTRIBUTE_NAME), user);
254 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
255 FieldsValidator acutualFieldValidator = null;
256 FieldsValidator expectedFieldValidator = new FieldsValidator();
257 List<FieldName> fields = new ArrayList<>();
258 expectedFieldValidator.setHttpStatusCode((long) 200);
259 expectedFieldValidator.setFields(fields);
260 expectedFieldValidator.setErrorCode(null);
261 Mockito.when(!adminRolesService.isSuperAdmin(user)).thenReturn(true);
262 Mockito.when(functionalMenuService.regenerateAncestorTable()).thenReturn(expectedFieldValidator);
263 acutualFieldValidator = functionalMenuController.regenerateAncestorTable(mockedRequest, mockedResponse);
264 assertTrue(acutualFieldValidator.equals(expectedFieldValidator));
268 public void getMenuItemsExceptionTest(){
269 List<FunctionalMenuItem> actualmenuItems = null;
270 List<FunctionalMenuItem> expectedmenuItems = null;
272 Mockito.when(functionalMenuController.getMenuItemsForAuthUser(mockedRequest, mockedResponse)).thenThrow(nullPointerException);
273 actualmenuItems = functionalMenuController.getMenuItemsForAuthUser(mockedRequest, mockedResponse);
274 assertEquals(actualmenuItems, expectedmenuItems);
278 public void getFunctionalMenuStaticInfoExceptionTest(){
279 String fnMenuStaticactualResponse = null;
280 String fnMenuStaticexpectedResponse = null;
281 String orgUserIdStr = null;
283 EPUser user = mockUser.mockEPUser();
284 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
285 Mockito.when(searchService.searchUserByUserId(orgUserIdStr)).thenReturn(user);
286 fnMenuStaticactualResponse = functionalMenuController.getFunctionalMenuStaticInfo(mockedRequest, mockedResponse);
288 assertEquals(fnMenuStaticactualResponse, fnMenuStaticexpectedResponse);
293 public void getFunctionalMenuStaticInfoTest(){
294 String fnMenuStaticactualResponse = null;
295 String fnMenuStaticexpectedResponse = "{\"firstName\":\"test\",\"lastName\":\"test\",\"last_login\":\"09/08/2017 03:48:13 -0400 am\",\"userId\":\"guestT\",\"isSystemUser\":\"false\",\"email\":\"test\"}";
296 String orgUserIdStr = null;
298 EPUser user = mockUser.mockEPUser();
299 user.setEmail("test");
300 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
301 Mockito.when(searchService.searchUserByUserId(orgUserIdStr)).thenReturn(user);
302 fnMenuStaticactualResponse = functionalMenuController.getFunctionalMenuStaticInfo(mockedRequest, mockedResponse);
303 assertEquals(fnMenuStaticactualResponse.length(), fnMenuStaticexpectedResponse.length());
307 public void getMenuItemsForAuthUserNullTest(){
308 List<FunctionalMenuItem> actualmenuItems = null;
309 List<FunctionalMenuItem> expectedmenuItems = null;
311 actualmenuItems = functionalMenuController.getMenuItemsForAuthUser(mockedRequest, mockedResponse);
312 assertEquals(actualmenuItems, expectedmenuItems);
316 public void getMenuItemsForAuthUserIsSuperAdminTest(){
317 List<FunctionalMenuItem> actualmenuItems = null;
318 List<FunctionalMenuItem> expectedmenuItems = new ArrayList<FunctionalMenuItem>();
319 EPUser user = mockUser.mockEPUser();
320 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
321 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
323 actualmenuItems = functionalMenuController.getMenuItemsForAuthUser(mockedRequest, mockedResponse);
324 assertEquals(actualmenuItems, expectedmenuItems);
328 public void getMenuItemsForAuthUserTest(){
329 List<FunctionalMenuItem> actualmenuItems = null;
330 List<FunctionalMenuItem> expectedmenuItems = new ArrayList<FunctionalMenuItem>();
331 EPUser user = mockUser.mockEPUser();
332 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
333 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
335 actualmenuItems = functionalMenuController.getMenuItemsForAuthUser(mockedRequest, mockedResponse);
336 assertEquals(actualmenuItems, expectedmenuItems);
340 public void getFunctionalMenuItemDetailsBadPermissionTest(){
342 FunctionalMenuItem actualmenuItem = null;
343 FunctionalMenuItem expectedmenuItem = null;
344 EPUser user = mockUser.mockEPUser();
345 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
347 actualmenuItem = functionalMenuController.getFunctionalMenuItemDetails(mockedRequest, menuId, mockedResponse);
348 assertEquals(actualmenuItem, expectedmenuItem);
352 public void getFunctionalMenuItemDetailsExceptionTest(){
354 FunctionalMenuItem actualmenuItem = null;
355 FunctionalMenuItem expectedmenuItem = null;
356 EPUser user = mockUser.mockEPUser();
357 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
358 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
359 Mockito.when(functionalMenuService.getFunctionalMenuItemDetails(menuId)).thenThrow(nullPointerException);
361 actualmenuItem = functionalMenuController.getFunctionalMenuItemDetails(mockedRequest, menuId, mockedResponse);
362 assertEquals(actualmenuItem, expectedmenuItem);
366 public void getFunctionalMenuItemDetailsTest(){
368 FunctionalMenuItem actualmenuItem = null;
369 FunctionalMenuItem expectedmenuItem = null;
370 EPUser user = mockUser.mockEPUser();
371 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
372 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
373 Mockito.when(functionalMenuService.getFunctionalMenuItemDetails(menuId)).thenReturn(actualmenuItem);
375 actualmenuItem = functionalMenuController.getFunctionalMenuItemDetails(mockedRequest, menuId, mockedResponse);
376 assertEquals(actualmenuItem, expectedmenuItem);
380 public void getMenuItemsForEditingTest(){
381 List<FunctionalMenuItem> actualMenuItems = null;
382 List<FunctionalMenuItem> expectedMenuItems = null;
383 EPUser user = mockUser.mockEPUser();
384 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
385 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
386 Mockito.when(functionalMenuService.getFunctionalMenuItems(true)).thenReturn(actualMenuItems);
388 actualMenuItems = functionalMenuController.getMenuItemsForEditing(mockedRequest, mockedResponse);
389 assertEquals(actualMenuItems, expectedMenuItems);
393 public void getMenuItemsForEditingBadPermissionsTest(){
394 List<FunctionalMenuItem> actualMenuItems = null;
395 List<FunctionalMenuItem> expectedMenuItems = null;
396 EPUser user = mockUser.mockEPUser();
397 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
398 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
399 Mockito.when(functionalMenuService.getFunctionalMenuItems(true)).thenReturn(actualMenuItems);
401 actualMenuItems = functionalMenuController.getMenuItemsForEditing(mockedRequest, mockedResponse);
402 assertEquals(actualMenuItems, expectedMenuItems);
406 public void getMenuItemsForEditingExceptionTest(){
407 List<FunctionalMenuItem> actualMenuItems = null;
408 List<FunctionalMenuItem> expectedMenuItems = null;
409 EPUser user = mockUser.mockEPUser();
410 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
411 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
412 Mockito.when(functionalMenuService.getFunctionalMenuItems(true)).thenThrow(nullPointerException);
413 actualMenuItems = functionalMenuController.getMenuItemsForEditing(mockedRequest, mockedResponse);
414 assertEquals(actualMenuItems, expectedMenuItems);
418 public void getMenuItemsForNotificationsExceptionTest(){
419 List<FunctionalMenuItem> actualMenuItems = null;
420 List<FunctionalMenuItem> expectedMenuItems = null;
421 Mockito.when(functionalMenuService.getFunctionalMenuItemsForNotificationTree(true)).thenThrow(nullPointerException);
423 actualMenuItems = functionalMenuController.getMenuItemsForNotifications(mockedRequest, mockedResponse);
424 assertEquals(actualMenuItems, expectedMenuItems);
427 public void getMenuItemsForNotificationsTest(){
428 List<FunctionalMenuItem> actualMenuItems = null;
429 List<FunctionalMenuItem> expectedMenuItems = new ArrayList<FunctionalMenuItem>();
430 Mockito.when(functionalMenuService.getFunctionalMenuItemsForNotificationTree(false)).thenReturn(actualMenuItems);
432 actualMenuItems = functionalMenuController.getMenuItemsForNotifications(mockedRequest, mockedResponse);
433 assertEquals(actualMenuItems, expectedMenuItems);
437 public void getMenuItemsForAppTest(){
438 Integer appId = 1234;
439 List<FunctionalMenuItem> actualMenuItems = null;
440 List<FunctionalMenuItem> expectedMenuItems = null;
441 Mockito.when(functionalMenuService.getFunctionalMenuItemsForApp(appId)).thenReturn(actualMenuItems);
443 actualMenuItems = functionalMenuController.getMenuItemsForApp(mockedRequest, appId);
444 assertEquals(actualMenuItems, expectedMenuItems);
448 public void getMenuItemsForAppExceptionTest(){
449 Integer appId = 1234;
450 List<FunctionalMenuItem> actualMenuItems = null;
451 List<FunctionalMenuItem> expectedMenuItems = null;
452 Mockito.when(functionalMenuService.getFunctionalMenuItemsForApp(appId)).thenThrow(nullPointerException);
454 actualMenuItems = functionalMenuController.getMenuItemsForApp(mockedRequest, appId);
455 assertEquals(actualMenuItems, expectedMenuItems);
459 public void getMenuItemsForUserTest(){
460 String orgUserId ="test";
461 List<FunctionalMenuItem> actualMenuItems = null;
462 List<FunctionalMenuItem> expectedMenuItems = null;
463 Mockito.when(functionalMenuService.getFunctionalMenuItemsForUser(orgUserId)).thenReturn(actualMenuItems);
465 actualMenuItems = functionalMenuController.getMenuItemsForUser(mockedRequest, orgUserId);
466 assertEquals(actualMenuItems, expectedMenuItems);
470 public void getMenuItemsForUserExceptionTest(){
471 String orgUserId ="test";
472 List<FunctionalMenuItem> actualMenuItems = null;
473 List<FunctionalMenuItem> expectedMenuItems = null;
474 Mockito.when(functionalMenuService.getFunctionalMenuItemsForUser(orgUserId)).thenThrow(nullPointerException);
476 actualMenuItems = functionalMenuController.getMenuItemsForUser(mockedRequest, orgUserId);
477 assertEquals(actualMenuItems, expectedMenuItems);
481 public void createFunctionalMenuItemTest(){
482 FieldsValidator actualFieldsValidator = new FieldsValidator();
483 FieldsValidator expectedFieldsValidator = new FieldsValidator();
484 List<FieldName> fields = new ArrayList<>();
485 expectedFieldsValidator.setHttpStatusCode((long) 200);
486 expectedFieldsValidator.setFields(fields);
487 expectedFieldsValidator.setErrorCode(null);
488 FunctionalMenuItemWithRoles menuItemJson = new FunctionalMenuItemWithRoles();
489 EPUser user = mockUser.mockEPUser();
490 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
491 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
492 Mockito.when(functionalMenuService.createFunctionalMenuItem(menuItemJson)).thenReturn(expectedFieldsValidator);
493 actualFieldsValidator = functionalMenuController.createFunctionalMenuItem(mockedRequest, menuItemJson, mockedResponse);
494 assertEquals(actualFieldsValidator, expectedFieldsValidator);
498 public void createFunctionalMenuItemBadPermisssionsTest(){
499 FieldsValidator actualFieldsValidator = null;
500 FieldsValidator expectedFieldsValidator = null;
501 FunctionalMenuItemWithRoles menuItemJson = new FunctionalMenuItemWithRoles();
502 EPUser user = mockUser.mockEPUser();
503 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
504 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
505 Mockito.when(functionalMenuService.createFunctionalMenuItem(menuItemJson)).thenReturn(expectedFieldsValidator);
506 actualFieldsValidator = functionalMenuController.createFunctionalMenuItem(mockedRequest, menuItemJson, mockedResponse);
507 assertEquals(expectedFieldsValidator, actualFieldsValidator);
511 public void getFavoritesForUserTest(){
512 List<FavoritesFunctionalMenuItemJson> actualFavoritesFunctionalMenuItemsJson = null;
513 List<FavoritesFunctionalMenuItemJson> expectedFunctionalMenuItemsJson = new ArrayList<FavoritesFunctionalMenuItemJson>();
514 EPUser user = mockUser.mockEPUser();
515 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
516 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
517 Mockito.when(functionalMenuService.getFavoriteItems(user.getId())).thenReturn(expectedFunctionalMenuItemsJson);
518 actualFavoritesFunctionalMenuItemsJson = functionalMenuController.getFavoritesForUser(mockedRequest, mockedResponse);
519 assertEquals(actualFavoritesFunctionalMenuItemsJson, expectedFunctionalMenuItemsJson);
523 public void deleteFavoriteItemTest(){
524 Long userId = (long)1;
525 Long menuId = (long)1;
526 FieldsValidator actualFieldsValidator = new FieldsValidator();
527 FieldsValidator expectedFieldsValidator = new FieldsValidator();
528 List<FieldName> fields = new ArrayList<>();
529 expectedFieldsValidator.setHttpStatusCode((long) 200);
530 expectedFieldsValidator.setFields(fields);
531 expectedFieldsValidator.setErrorCode(null);
532 EPUser user = mockUser.mockEPUser();
533 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
534 Mockito.when(functionalMenuService.removeFavoriteItem(user.getId(), menuId)).thenReturn(actualFieldsValidator);
535 actualFieldsValidator = functionalMenuController.deleteFavoriteItem(mockedRequest, menuId, mockedResponse);
536 assertEquals(actualFieldsValidator, expectedFieldsValidator);
540 public void addFavoriteItemTest(){
541 FavoritesFunctionalMenuItem menuItemJson = new FavoritesFunctionalMenuItem();
542 FieldsValidator actualFieldsValidator = new FieldsValidator();
543 FieldsValidator expectedFieldsValidator = new FieldsValidator();
544 List<FieldName> fields = new ArrayList<>();
545 expectedFieldsValidator.setHttpStatusCode((long) 200);
546 expectedFieldsValidator.setFields(fields);
547 expectedFieldsValidator.setErrorCode(null);
548 EPUser user = mockUser.mockEPUser();
549 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
550 Mockito.when(functionalMenuService.setFavoriteItem(menuItemJson)).thenReturn(actualFieldsValidator);
551 actualFieldsValidator = functionalMenuController.addFavoriteItem(mockedRequest, menuItemJson, mockedResponse);
552 assertEquals(actualFieldsValidator, expectedFieldsValidator);
556 public void getMenuItemsTest(){
557 List<FunctionalMenuItem> actualFunctionalMenuItems = new ArrayList<FunctionalMenuItem>();
558 List<FunctionalMenuItem> expectedFunctionalMenuItems = new ArrayList<FunctionalMenuItem>();
559 List<FunctionalMenuItem> menuItems = new ArrayList<FunctionalMenuItem>();
560 Mockito.when(functionalMenuService.getFunctionalMenuItems()).thenReturn(menuItems);
561 actualFunctionalMenuItems = functionalMenuController.getMenuItems(mockedRequest, mockedResponse);
562 assertEquals(actualFunctionalMenuItems, expectedFunctionalMenuItems);
566 public void deleteFunctionalMenuItemTest(){
567 Long menuId = (long)1;
568 FieldsValidator actualFieldsValidator = new FieldsValidator();
569 FieldsValidator expectedFieldsValidator = new FieldsValidator();
570 List<FieldName> fields = new ArrayList<>();
571 expectedFieldsValidator.setHttpStatusCode((long) 200);
572 expectedFieldsValidator.setFields(fields);
573 expectedFieldsValidator.setErrorCode(null);
574 EPUser user = mockUser.mockEPUser();
575 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
576 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
577 Mockito.when(functionalMenuService.deleteFunctionalMenuItem(menuId)).thenReturn(actualFieldsValidator);
578 actualFieldsValidator = functionalMenuController.deleteFunctionalMenuItem(mockedRequest, menuId, mockedResponse);
579 assertEquals(actualFieldsValidator, expectedFieldsValidator);
583 public void deleteFunctionalMenuItemBadPermissionsTest(){
584 Long menuId = (long)1;
585 FieldsValidator actualFieldsValidator = null;
586 FieldsValidator expectedFieldsValidator = null;
587 EPUser user = mockUser.mockEPUser();
588 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
589 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
590 Mockito.when(functionalMenuService.deleteFunctionalMenuItem(menuId)).thenReturn(actualFieldsValidator);
591 actualFieldsValidator = functionalMenuController.deleteFunctionalMenuItem(mockedRequest, menuId, mockedResponse);
592 assertEquals(actualFieldsValidator, expectedFieldsValidator);
596 public void editFunctionalMenuItemTest(){
597 FunctionalMenuItemWithRoles menuItemJson = new FunctionalMenuItemWithRoles();
598 FieldsValidator actualFieldsValidator = new FieldsValidator();
599 FieldsValidator expectedFieldsValidator = new FieldsValidator();
600 List<FieldName> fields = new ArrayList<>();
601 expectedFieldsValidator.setHttpStatusCode((long) 200);
602 expectedFieldsValidator.setFields(fields);
603 expectedFieldsValidator.setErrorCode(null);
604 EPUser user = mockUser.mockEPUser();
605 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
606 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
607 Mockito.when(functionalMenuService.editFunctionalMenuItem(menuItemJson)).thenReturn(actualFieldsValidator);
608 actualFieldsValidator = functionalMenuController.editFunctionalMenuItem(mockedRequest, menuItemJson, mockedResponse);
609 assertEquals(actualFieldsValidator, expectedFieldsValidator);
613 public void editFunctionalMenuItemBadPermissionsTest(){
614 FunctionalMenuItemWithRoles menuItemJson = new FunctionalMenuItemWithRoles();
615 FieldsValidator actualFieldsValidator = null;
616 FieldsValidator expectedFieldsValidator = null;
617 EPUser user = mockUser.mockEPUser();
618 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
619 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
620 Mockito.when(functionalMenuService.editFunctionalMenuItem(menuItemJson)).thenReturn(actualFieldsValidator);
621 actualFieldsValidator = functionalMenuController.editFunctionalMenuItem(mockedRequest, menuItemJson, mockedResponse);
622 assertEquals(expectedFieldsValidator, actualFieldsValidator);
626 public void getECOMPTitleTest(){
627 PortalRestResponse<String> actualportalRestResponse = null;
628 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
629 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
630 expectedportalRestResponse.setMessage("success");
631 expectedportalRestResponse.setResponse("Portal");
632 PowerMockito.mockStatic(SystemProperties.class);
633 Mockito.when(SystemProperties.getProperty(SystemProperties.APP_DISPLAY_NAME)).thenReturn("Portal");
634 actualportalRestResponse = functionalMenuController.getECOMPTitle(mockedRequest, mockedResponse);
635 assertEquals(actualportalRestResponse, expectedportalRestResponse);
639 public void getECOMPTitleExceptionTest(){
640 PortalRestResponse<String> actualportalRestResponse = null;
641 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
642 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
643 expectedportalRestResponse.setMessage(null);
644 expectedportalRestResponse.setResponse(null);
645 PowerMockito.mockStatic(SystemProperties.class);
647 Mockito.when(SystemProperties.getProperty(SystemProperties.APP_DISPLAY_NAME)).thenThrow(nullPointerException);
648 actualportalRestResponse = functionalMenuController.getECOMPTitle(mockedRequest, mockedResponse);
649 assertEquals(actualportalRestResponse, expectedportalRestResponse);