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.assertTrue;
43 import java.io.IOException;
44 import java.util.ArrayList;
45 import java.util.List;
47 import javax.servlet.http.HttpServletRequest;
48 import javax.servlet.http.HttpServletResponse;
49 import javax.servlet.http.HttpSession;
51 import org.junit.Before;
52 import org.junit.Test;
53 import org.junit.runner.RunWith;
54 import org.mockito.InjectMocks;
55 import org.mockito.Mock;
56 import org.mockito.Mockito;
57 import org.mockito.MockitoAnnotations;
58 import org.mockito.runners.MockitoJUnitRunner;
59 import org.onap.portalapp.portal.controller.FunctionalMenuController;
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.FunctionalMenuItem;
76 import org.onap.portalapp.portal.transport.FunctionalMenuItemWithRoles;
77 import org.onap.portalapp.portal.transport.FieldsValidator.FieldName;
78 import org.onap.portalapp.util.EPUserUtils;
79 import org.onap.portalsdk.core.service.DataAccessService;
80 import org.onap.portalsdk.core.util.SystemProperties;
81 import org.powermock.api.mockito.PowerMockito;
82 import org.powermock.core.classloader.annotations.PrepareForTest;
83 import org.powermock.modules.junit4.PowerMockRunner;
85 @RunWith(PowerMockRunner.class)
86 @PrepareForTest(SystemProperties.class)
87 public class FunctionalMenuControllerTest extends MockitoTestSuite {
89 String userid = "ab1234";
92 FunctionalMenuService functionalMenuService = new FunctionalMenuServiceImpl();
95 FunctionalMenuController functionalMenuController = new FunctionalMenuController();
98 private DataAccessService dataAccessService;
101 SearchService searchService;
104 AdminRolesService adminRolesService = new AdminRolesServiceImpl();
106 NullPointerException nullPointerException = new NullPointerException();
109 public void setup() {
110 MockitoAnnotations.initMocks(this);
113 MockitoTestSuite mockitoTestSuite = new MockitoTestSuite();
115 HttpServletRequest mockedRequest = mockitoTestSuite.getMockedRequest();
116 HttpServletResponse mockedResponse = mockitoTestSuite.getMockedResponse();
119 EPUserUtils ePUserUtils = new EPUserUtils();
124 MockEPUser mockUser = new MockEPUser();
126 List<BusinessCardApplicationRolesList> appRoles = new ArrayList<BusinessCardApplicationRolesList>();
127 List<BusinessCardApplicationRolesList> appRolesActual = new ArrayList<BusinessCardApplicationRolesList>();
129 List<BusinessCardApplicationRole> userAppRoleList = new ArrayList<BusinessCardApplicationRole>();
131 public List<BusinessCardApplicationRole> mockBusinessCardApplicationRole() {
132 List<BusinessCardApplicationRole> userAppRoleList = new ArrayList<BusinessCardApplicationRole>();
134 BusinessCardApplicationRole businessCardApplicationRole = new BusinessCardApplicationRole();
135 businessCardApplicationRole.setRoleName("ADMIN");
136 businessCardApplicationRole.setAppName("ASDC");
138 BusinessCardApplicationRole businessCardApplicationRole1 = new BusinessCardApplicationRole();
139 businessCardApplicationRole1.setAppName("ASDC");
140 businessCardApplicationRole1.setRoleName("Tester");
142 userAppRoleList.add(businessCardApplicationRole);
143 userAppRoleList.add(businessCardApplicationRole1);
144 return userAppRoleList;
147 public List<BusinessCardApplicationRolesList> mockBusinessCardApplicationRolesList() {
148 List<BusinessCardApplicationRolesList> appRolesActual = new ArrayList<BusinessCardApplicationRolesList>();
150 BusinessCardApplicationRolesList businessCardApplicationRolesList = new BusinessCardApplicationRolesList();
151 businessCardApplicationRolesList.setAppName("ASDC");
153 List<String> roleNames = new ArrayList<String>();
154 roleNames.add("ADMIN");
155 roleNames.add("Tester");
156 businessCardApplicationRolesList.setRoleNames(roleNames);
158 appRolesActual.add(businessCardApplicationRolesList);
159 return appRolesActual;
163 public void getAppListTestIfAppAlredyExistsBusinessCardApplicationRolesList() throws IOException {
165 userAppRoleList = mockBusinessCardApplicationRole();
166 appRolesActual = mockBusinessCardApplicationRolesList();
168 Mockito.when(functionalMenuService.getUserAppRolesList(userid)).thenReturn(userAppRoleList);
170 appRoles = functionalMenuController.getAppList(mockedRequest, userid);
172 assertEquals(appRolesActual.size(), appRoles.size());
173 assertEquals(appRolesActual.get(0).getAppName(), appRoles.get(0).getAppName());
174 assertEquals(appRolesActual.get(0).getRoleNames(), appRoles.get(0).getRoleNames());
179 public void editFunctionalMenuItemXSSTest(){
180 FunctionalMenuItemWithRoles menuItemJson = new FunctionalMenuItemWithRoles();
181 menuItemJson.url = "1<b>tes<img src=‘~‘ onerror=prompt(32)>t_menu";
182 FieldsValidator actualFieldsValidator = new FieldsValidator();
183 FieldsValidator expectedFieldsValidator = new FieldsValidator();
184 List<FieldName> fields = new ArrayList<>();
185 expectedFieldsValidator.setHttpStatusCode(406L);
186 expectedFieldsValidator.setFields(fields);
187 expectedFieldsValidator.setErrorCode(null);
188 EPUser user = mockUser.mockEPUser();
189 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
190 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
191 Mockito.when(functionalMenuService.editFunctionalMenuItem(menuItemJson)).thenReturn(actualFieldsValidator);
192 actualFieldsValidator = functionalMenuController.editFunctionalMenuItem(mockedRequest, menuItemJson, mockedResponse);
193 assertEquals(actualFieldsValidator, expectedFieldsValidator);
197 public void getAppListTestIfAppDoesnotExistsInBusinessCardApplicationRolesList() throws IOException {
199 userAppRoleList = mockBusinessCardApplicationRole();
200 BusinessCardApplicationRole businessCardApplicationRole = new BusinessCardApplicationRole();
201 businessCardApplicationRole.setAppName("CCD");
202 businessCardApplicationRole.setRoleName("ADMIN");
203 userAppRoleList.add(businessCardApplicationRole);
204 appRolesActual = mockBusinessCardApplicationRolesList();
205 BusinessCardApplicationRolesList businessCardApplicationRolesList = new BusinessCardApplicationRolesList();
206 businessCardApplicationRolesList.setAppName("CCD");
207 List<String> roleNames1 = new ArrayList<String>();
208 roleNames1.add("ADMIN");
209 businessCardApplicationRolesList.setRoleNames(roleNames1);
210 appRolesActual.add(businessCardApplicationRolesList);
211 Mockito.when(functionalMenuService.getUserAppRolesList(userid)).thenReturn(userAppRoleList);
212 appRoles = functionalMenuController.getAppList(mockedRequest, userid);
213 assertEquals(appRolesActual.size(), appRoles.size());
214 assertEquals(appRolesActual.get(0).getAppName(), appRoles.get(0).getAppName());
215 assertEquals(appRolesActual.get(0).getRoleNames(), appRoles.get(0).getRoleNames());
216 assertEquals(appRolesActual.get(1).getAppName(), appRoles.get(1).getAppName());
217 assertEquals(appRolesActual.get(1).getRoleNames(), appRoles.get(1).getRoleNames());
222 public void regenerateAncestorTableTest() {
223 EPUser user = mockUser.mockEPUser();
225 HttpSession session = mockedRequest.getSession();
226 session.setAttribute(SystemProperties.getProperty(SystemProperties.USER_ATTRIBUTE_NAME), user);
227 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
228 FieldsValidator acutualFieldValidator = null;
229 FieldsValidator expectedFieldValidator = new FieldsValidator();
230 List<FieldName> fields = new ArrayList<>();
231 expectedFieldValidator.setHttpStatusCode((long) 200);
232 expectedFieldValidator.setFields(fields);
233 expectedFieldValidator.setErrorCode(null);
234 Mockito.when(!adminRolesService.isSuperAdmin(user)).thenReturn(true);
235 Mockito.when(functionalMenuService.regenerateAncestorTable()).thenReturn(expectedFieldValidator);
236 acutualFieldValidator = functionalMenuController.regenerateAncestorTable(mockedRequest, mockedResponse);
237 assertTrue(acutualFieldValidator.equals(expectedFieldValidator));
241 public void getMenuItemsExceptionTest(){
242 List<FunctionalMenuItem> actualmenuItems = null;
243 List<FunctionalMenuItem> expectedmenuItems = null;
245 Mockito.when(functionalMenuController.getMenuItemsForAuthUser(mockedRequest, mockedResponse)).thenThrow(nullPointerException);
246 actualmenuItems = functionalMenuController.getMenuItemsForAuthUser(mockedRequest, mockedResponse);
247 assertEquals(actualmenuItems, expectedmenuItems);
251 public void getFunctionalMenuStaticInfoExceptionTest(){
252 String fnMenuStaticactualResponse = null;
253 String fnMenuStaticexpectedResponse = null;
254 String orgUserIdStr = null;
256 EPUser user = mockUser.mockEPUser();
257 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
258 Mockito.when(searchService.searchUserByUserId(orgUserIdStr)).thenReturn(user);
259 fnMenuStaticactualResponse = functionalMenuController.getFunctionalMenuStaticInfo(mockedRequest, mockedResponse);
261 assertEquals(fnMenuStaticactualResponse, fnMenuStaticexpectedResponse);
266 public void getFunctionalMenuStaticInfoTest(){
267 String fnMenuStaticactualResponse = null;
268 String fnMenuStaticexpectedResponse = "{\"firstName\":\"test\",\"lastName\":\"test\",\"last_login\":\"09/08/2017 03:48:13 -0400 am\",\"userId\":\"guestT\",\"email\":\"test\"}";
269 String orgUserIdStr = null;
271 EPUser user = mockUser.mockEPUser();
272 user.setEmail("test");
273 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
274 Mockito.when(searchService.searchUserByUserId(orgUserIdStr)).thenReturn(user);
275 fnMenuStaticactualResponse = functionalMenuController.getFunctionalMenuStaticInfo(mockedRequest, mockedResponse);
276 assertEquals(fnMenuStaticactualResponse.length(), fnMenuStaticexpectedResponse.length());
280 public void getMenuItemsForAuthUserNullTest(){
281 List<FunctionalMenuItem> actualmenuItems = null;
282 List<FunctionalMenuItem> expectedmenuItems = null;
284 actualmenuItems = functionalMenuController.getMenuItemsForAuthUser(mockedRequest, mockedResponse);
285 assertEquals(actualmenuItems, expectedmenuItems);
289 public void getMenuItemsForAuthUserIsSuperAdminTest(){
290 List<FunctionalMenuItem> actualmenuItems = null;
291 List<FunctionalMenuItem> expectedmenuItems = new ArrayList<FunctionalMenuItem>();
292 EPUser user = mockUser.mockEPUser();
293 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
294 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
296 actualmenuItems = functionalMenuController.getMenuItemsForAuthUser(mockedRequest, mockedResponse);
297 assertEquals(actualmenuItems, expectedmenuItems);
301 public void getMenuItemsForAuthUserTest(){
302 List<FunctionalMenuItem> actualmenuItems = null;
303 List<FunctionalMenuItem> expectedmenuItems = new ArrayList<FunctionalMenuItem>();
304 EPUser user = mockUser.mockEPUser();
305 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
306 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
308 actualmenuItems = functionalMenuController.getMenuItemsForAuthUser(mockedRequest, mockedResponse);
309 assertEquals(actualmenuItems, expectedmenuItems);
313 public void getFunctionalMenuItemDetailsBadPermissionTest(){
315 FunctionalMenuItem actualmenuItem = null;
316 FunctionalMenuItem expectedmenuItem = null;
317 EPUser user = mockUser.mockEPUser();
318 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
320 actualmenuItem = functionalMenuController.getFunctionalMenuItemDetails(mockedRequest, menuId, mockedResponse);
321 assertEquals(actualmenuItem, expectedmenuItem);
325 public void getFunctionalMenuItemDetailsExceptionTest(){
327 FunctionalMenuItem actualmenuItem = null;
328 FunctionalMenuItem expectedmenuItem = null;
329 EPUser user = mockUser.mockEPUser();
330 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
331 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
332 Mockito.when(functionalMenuService.getFunctionalMenuItemDetails(menuId)).thenThrow(nullPointerException);
334 actualmenuItem = functionalMenuController.getFunctionalMenuItemDetails(mockedRequest, menuId, mockedResponse);
335 assertEquals(actualmenuItem, expectedmenuItem);
339 public void getFunctionalMenuItemDetailsTest(){
341 FunctionalMenuItem actualmenuItem = null;
342 FunctionalMenuItem expectedmenuItem = null;
343 EPUser user = mockUser.mockEPUser();
344 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
345 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
346 Mockito.when(functionalMenuService.getFunctionalMenuItemDetails(menuId)).thenReturn(actualmenuItem);
348 actualmenuItem = functionalMenuController.getFunctionalMenuItemDetails(mockedRequest, menuId, mockedResponse);
349 assertEquals(actualmenuItem, expectedmenuItem);
353 public void getMenuItemsForEditingTest(){
354 List<FunctionalMenuItem> actualMenuItems = null;
355 List<FunctionalMenuItem> expectedMenuItems = 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.getFunctionalMenuItems(true)).thenReturn(actualMenuItems);
361 actualMenuItems = functionalMenuController.getMenuItemsForEditing(mockedRequest, mockedResponse);
362 assertEquals(actualMenuItems, expectedMenuItems);
366 public void getMenuItemsForEditingBadPermissionsTest(){
367 List<FunctionalMenuItem> actualMenuItems = null;
368 List<FunctionalMenuItem> expectedMenuItems = null;
369 EPUser user = mockUser.mockEPUser();
370 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
371 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
372 Mockito.when(functionalMenuService.getFunctionalMenuItems(true)).thenReturn(actualMenuItems);
374 actualMenuItems = functionalMenuController.getMenuItemsForEditing(mockedRequest, mockedResponse);
375 assertEquals(actualMenuItems, expectedMenuItems);
379 public void getMenuItemsForEditingExceptionTest(){
380 List<FunctionalMenuItem> actualMenuItems = null;
381 List<FunctionalMenuItem> expectedMenuItems = null;
382 EPUser user = mockUser.mockEPUser();
383 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
384 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
385 Mockito.when(functionalMenuService.getFunctionalMenuItems(true)).thenThrow(nullPointerException);
386 actualMenuItems = functionalMenuController.getMenuItemsForEditing(mockedRequest, mockedResponse);
387 assertEquals(actualMenuItems, expectedMenuItems);
391 public void getMenuItemsForNotificationsExceptionTest(){
392 List<FunctionalMenuItem> actualMenuItems = null;
393 List<FunctionalMenuItem> expectedMenuItems = null;
394 Mockito.when(functionalMenuService.getFunctionalMenuItemsForNotificationTree(true)).thenThrow(nullPointerException);
396 actualMenuItems = functionalMenuController.getMenuItemsForNotifications(mockedRequest, mockedResponse);
397 assertEquals(actualMenuItems, expectedMenuItems);
400 public void getMenuItemsForNotificationsTest(){
401 List<FunctionalMenuItem> actualMenuItems = null;
402 List<FunctionalMenuItem> expectedMenuItems = new ArrayList<FunctionalMenuItem>();
403 Mockito.when(functionalMenuService.getFunctionalMenuItemsForNotificationTree(false)).thenReturn(actualMenuItems);
405 actualMenuItems = functionalMenuController.getMenuItemsForNotifications(mockedRequest, mockedResponse);
406 assertEquals(actualMenuItems, expectedMenuItems);
410 public void getMenuItemsForAppTest(){
411 Integer appId = 1234;
412 List<FunctionalMenuItem> actualMenuItems = null;
413 List<FunctionalMenuItem> expectedMenuItems = null;
414 Mockito.when(functionalMenuService.getFunctionalMenuItemsForApp(appId)).thenReturn(actualMenuItems);
416 actualMenuItems = functionalMenuController.getMenuItemsForApp(mockedRequest, appId);
417 assertEquals(actualMenuItems, expectedMenuItems);
421 public void getMenuItemsForAppExceptionTest(){
422 Integer appId = 1234;
423 List<FunctionalMenuItem> actualMenuItems = null;
424 List<FunctionalMenuItem> expectedMenuItems = null;
425 Mockito.when(functionalMenuService.getFunctionalMenuItemsForApp(appId)).thenThrow(nullPointerException);
427 actualMenuItems = functionalMenuController.getMenuItemsForApp(mockedRequest, appId);
428 assertEquals(actualMenuItems, expectedMenuItems);
432 public void getMenuItemsForUserTest(){
433 String orgUserId ="test";
434 List<FunctionalMenuItem> actualMenuItems = null;
435 List<FunctionalMenuItem> expectedMenuItems = null;
436 Mockito.when(functionalMenuService.getFunctionalMenuItemsForUser(orgUserId)).thenReturn(actualMenuItems);
438 actualMenuItems = functionalMenuController.getMenuItemsForUser(mockedRequest, orgUserId);
439 assertEquals(actualMenuItems, expectedMenuItems);
443 public void getMenuItemsForUserExceptionTest(){
444 String orgUserId ="test";
445 List<FunctionalMenuItem> actualMenuItems = null;
446 List<FunctionalMenuItem> expectedMenuItems = null;
447 Mockito.when(functionalMenuService.getFunctionalMenuItemsForUser(orgUserId)).thenThrow(nullPointerException);
449 actualMenuItems = functionalMenuController.getMenuItemsForUser(mockedRequest, orgUserId);
450 assertEquals(actualMenuItems, expectedMenuItems);
454 public void createFunctionalMenuItemTest(){
455 FieldsValidator actualFieldsValidator = new FieldsValidator();
456 FieldsValidator expectedFieldsValidator = new FieldsValidator();
457 List<FieldName> fields = new ArrayList<>();
458 expectedFieldsValidator.setHttpStatusCode((long) 200);
459 expectedFieldsValidator.setFields(fields);
460 expectedFieldsValidator.setErrorCode(null);
461 FunctionalMenuItemWithRoles menuItemJson = new FunctionalMenuItemWithRoles();
462 EPUser user = mockUser.mockEPUser();
463 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
464 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
465 Mockito.when(functionalMenuService.createFunctionalMenuItem(menuItemJson)).thenReturn(expectedFieldsValidator);
466 actualFieldsValidator = functionalMenuController.createFunctionalMenuItem(mockedRequest, menuItemJson, mockedResponse);
467 assertEquals(actualFieldsValidator, expectedFieldsValidator);
471 public void createFunctionalMenuItemBadPermisssionsTest(){
472 FieldsValidator actualFieldsValidator = null;
473 FieldsValidator expectedFieldsValidator = null;
474 FunctionalMenuItemWithRoles menuItemJson = new FunctionalMenuItemWithRoles();
475 EPUser user = mockUser.mockEPUser();
476 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
477 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
478 Mockito.when(functionalMenuService.createFunctionalMenuItem(menuItemJson)).thenReturn(expectedFieldsValidator);
479 actualFieldsValidator = functionalMenuController.createFunctionalMenuItem(mockedRequest, menuItemJson, mockedResponse);
480 assertEquals(expectedFieldsValidator, actualFieldsValidator);
484 public void getFavoritesForUserTest(){
485 List<FavoritesFunctionalMenuItemJson> actualFavoritesFunctionalMenuItemsJson = null;
486 List<FavoritesFunctionalMenuItemJson> expectedFunctionalMenuItemsJson = new ArrayList<FavoritesFunctionalMenuItemJson>();
487 EPUser user = mockUser.mockEPUser();
488 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
489 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
490 Mockito.when(functionalMenuService.getFavoriteItems(user.getId())).thenReturn(expectedFunctionalMenuItemsJson);
491 actualFavoritesFunctionalMenuItemsJson = functionalMenuController.getFavoritesForUser(mockedRequest, mockedResponse);
492 assertEquals(actualFavoritesFunctionalMenuItemsJson, expectedFunctionalMenuItemsJson);
496 public void deleteFavoriteItemTest(){
497 Long userId = (long)1;
498 Long menuId = (long)1;
499 FieldsValidator actualFieldsValidator = new FieldsValidator();
500 FieldsValidator expectedFieldsValidator = new FieldsValidator();
501 List<FieldName> fields = new ArrayList<>();
502 expectedFieldsValidator.setHttpStatusCode((long) 200);
503 expectedFieldsValidator.setFields(fields);
504 expectedFieldsValidator.setErrorCode(null);
505 EPUser user = mockUser.mockEPUser();
506 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
507 Mockito.when(functionalMenuService.removeFavoriteItem(user.getId(), menuId)).thenReturn(actualFieldsValidator);
508 actualFieldsValidator = functionalMenuController.deleteFavoriteItem(mockedRequest, menuId, mockedResponse);
509 assertEquals(actualFieldsValidator, expectedFieldsValidator);
513 public void addFavoriteItemTest(){
514 FavoritesFunctionalMenuItem menuItemJson = new FavoritesFunctionalMenuItem();
515 FieldsValidator actualFieldsValidator = new FieldsValidator();
516 FieldsValidator expectedFieldsValidator = new FieldsValidator();
517 List<FieldName> fields = new ArrayList<>();
518 expectedFieldsValidator.setHttpStatusCode((long) 200);
519 expectedFieldsValidator.setFields(fields);
520 expectedFieldsValidator.setErrorCode(null);
521 EPUser user = mockUser.mockEPUser();
522 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
523 Mockito.when(functionalMenuService.setFavoriteItem(menuItemJson)).thenReturn(actualFieldsValidator);
524 actualFieldsValidator = functionalMenuController.addFavoriteItem(mockedRequest, menuItemJson, mockedResponse);
525 assertEquals(actualFieldsValidator, expectedFieldsValidator);
529 public void getMenuItemsTest(){
530 List<FunctionalMenuItem> actualFunctionalMenuItems = new ArrayList<FunctionalMenuItem>();
531 List<FunctionalMenuItem> expectedFunctionalMenuItems = new ArrayList<FunctionalMenuItem>();
532 List<FunctionalMenuItem> menuItems = new ArrayList<FunctionalMenuItem>();
533 Mockito.when(functionalMenuService.getFunctionalMenuItems()).thenReturn(menuItems);
534 actualFunctionalMenuItems = functionalMenuController.getMenuItems(mockedRequest, mockedResponse);
535 assertEquals(actualFunctionalMenuItems, expectedFunctionalMenuItems);
539 public void deleteFunctionalMenuItemTest(){
540 Long menuId = (long)1;
541 FieldsValidator actualFieldsValidator = new FieldsValidator();
542 FieldsValidator expectedFieldsValidator = new FieldsValidator();
543 List<FieldName> fields = new ArrayList<>();
544 expectedFieldsValidator.setHttpStatusCode((long) 200);
545 expectedFieldsValidator.setFields(fields);
546 expectedFieldsValidator.setErrorCode(null);
547 EPUser user = mockUser.mockEPUser();
548 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
549 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
550 Mockito.when(functionalMenuService.deleteFunctionalMenuItem(menuId)).thenReturn(actualFieldsValidator);
551 actualFieldsValidator = functionalMenuController.deleteFunctionalMenuItem(mockedRequest, menuId, mockedResponse);
552 assertEquals(actualFieldsValidator, expectedFieldsValidator);
556 public void deleteFunctionalMenuItemBadPermissionsTest(){
557 Long menuId = (long)1;
558 FieldsValidator actualFieldsValidator = null;
559 FieldsValidator expectedFieldsValidator = null;
560 EPUser user = mockUser.mockEPUser();
561 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
562 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
563 Mockito.when(functionalMenuService.deleteFunctionalMenuItem(menuId)).thenReturn(actualFieldsValidator);
564 actualFieldsValidator = functionalMenuController.deleteFunctionalMenuItem(mockedRequest, menuId, mockedResponse);
565 assertEquals(actualFieldsValidator, expectedFieldsValidator);
569 public void editFunctionalMenuItemTest(){
570 FunctionalMenuItemWithRoles menuItemJson = new FunctionalMenuItemWithRoles();
571 FieldsValidator actualFieldsValidator = new FieldsValidator();
572 FieldsValidator expectedFieldsValidator = new FieldsValidator();
573 List<FieldName> fields = new ArrayList<>();
574 expectedFieldsValidator.setHttpStatusCode((long) 200);
575 expectedFieldsValidator.setFields(fields);
576 expectedFieldsValidator.setErrorCode(null);
577 EPUser user = mockUser.mockEPUser();
578 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
579 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
580 Mockito.when(functionalMenuService.editFunctionalMenuItem(menuItemJson)).thenReturn(actualFieldsValidator);
581 actualFieldsValidator = functionalMenuController.editFunctionalMenuItem(mockedRequest, menuItemJson, mockedResponse);
582 assertEquals(actualFieldsValidator, expectedFieldsValidator);
586 public void editFunctionalMenuItemBadPermissionsTest(){
587 FunctionalMenuItemWithRoles menuItemJson = new FunctionalMenuItemWithRoles();
588 FieldsValidator actualFieldsValidator = null;
589 FieldsValidator expectedFieldsValidator = null;
590 EPUser user = mockUser.mockEPUser();
591 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
592 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
593 Mockito.when(functionalMenuService.editFunctionalMenuItem(menuItemJson)).thenReturn(actualFieldsValidator);
594 actualFieldsValidator = functionalMenuController.editFunctionalMenuItem(mockedRequest, menuItemJson, mockedResponse);
595 assertEquals(expectedFieldsValidator, actualFieldsValidator);
599 public void getECOMPTitleTest(){
600 PortalRestResponse<String> actualportalRestResponse = null;
601 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
602 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
603 expectedportalRestResponse.setMessage("success");
604 expectedportalRestResponse.setResponse("Portal");
605 PowerMockito.mockStatic(SystemProperties.class);
606 Mockito.when(SystemProperties.getProperty(SystemProperties.APP_DISPLAY_NAME)).thenReturn("Portal");
607 actualportalRestResponse = functionalMenuController.getECOMPTitle(mockedRequest, mockedResponse);
608 assertEquals(actualportalRestResponse, expectedportalRestResponse);
612 public void getECOMPTitleExceptionTest(){
613 PortalRestResponse<String> actualportalRestResponse = null;
614 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
615 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
616 expectedportalRestResponse.setMessage(null);
617 expectedportalRestResponse.setResponse(null);
618 PowerMockito.mockStatic(SystemProperties.class);
620 Mockito.when(SystemProperties.getProperty(SystemProperties.APP_DISPLAY_NAME)).thenThrow(nullPointerException);
621 actualportalRestResponse = functionalMenuController.getECOMPTitle(mockedRequest, mockedResponse);
622 assertEquals(actualportalRestResponse, expectedportalRestResponse);