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 getAppListTestIfAppDoesnotExistsInBusinessCardApplicationRolesList() throws IOException {
181 userAppRoleList = mockBusinessCardApplicationRole();
182 BusinessCardApplicationRole businessCardApplicationRole = new BusinessCardApplicationRole();
183 businessCardApplicationRole.setAppName("CCD");
184 businessCardApplicationRole.setRoleName("ADMIN");
185 userAppRoleList.add(businessCardApplicationRole);
186 appRolesActual = mockBusinessCardApplicationRolesList();
187 BusinessCardApplicationRolesList businessCardApplicationRolesList = new BusinessCardApplicationRolesList();
188 businessCardApplicationRolesList.setAppName("CCD");
189 List<String> roleNames1 = new ArrayList<String>();
190 roleNames1.add("ADMIN");
191 businessCardApplicationRolesList.setRoleNames(roleNames1);
192 appRolesActual.add(businessCardApplicationRolesList);
193 Mockito.when(functionalMenuService.getUserAppRolesList(userid)).thenReturn(userAppRoleList);
194 appRoles = functionalMenuController.getAppList(mockedRequest, userid);
195 assertEquals(appRolesActual.size(), appRoles.size());
196 assertEquals(appRolesActual.get(0).getAppName(), appRoles.get(0).getAppName());
197 assertEquals(appRolesActual.get(0).getRoleNames(), appRoles.get(0).getRoleNames());
198 assertEquals(appRolesActual.get(1).getAppName(), appRoles.get(1).getAppName());
199 assertEquals(appRolesActual.get(1).getRoleNames(), appRoles.get(1).getRoleNames());
204 public void regenerateAncestorTableTest() {
205 EPUser user = mockUser.mockEPUser();
207 HttpSession session = mockedRequest.getSession();
208 session.setAttribute(SystemProperties.getProperty(SystemProperties.USER_ATTRIBUTE_NAME), user);
209 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
210 FieldsValidator acutualFieldValidator = null;
211 FieldsValidator expectedFieldValidator = new FieldsValidator();
212 List<FieldName> fields = new ArrayList<>();
213 expectedFieldValidator.setHttpStatusCode((long) 200);
214 expectedFieldValidator.setFields(fields);
215 expectedFieldValidator.setErrorCode(null);
216 Mockito.when(!adminRolesService.isSuperAdmin(user)).thenReturn(true);
217 Mockito.when(functionalMenuService.regenerateAncestorTable()).thenReturn(expectedFieldValidator);
218 acutualFieldValidator = functionalMenuController.regenerateAncestorTable(mockedRequest, mockedResponse);
219 assertTrue(acutualFieldValidator.equals(expectedFieldValidator));
223 public void getMenuItemsExceptionTest(){
224 List<FunctionalMenuItem> actualmenuItems = null;
225 List<FunctionalMenuItem> expectedmenuItems = null;
227 Mockito.when(functionalMenuController.getMenuItemsForAuthUser(mockedRequest, mockedResponse)).thenThrow(nullPointerException);
228 actualmenuItems = functionalMenuController.getMenuItemsForAuthUser(mockedRequest, mockedResponse);
229 assertEquals(actualmenuItems, expectedmenuItems);
233 public void getFunctionalMenuStaticInfoExceptionTest(){
234 String fnMenuStaticactualResponse = null;
235 String fnMenuStaticexpectedResponse = null;
236 String orgUserIdStr = null;
238 EPUser user = mockUser.mockEPUser();
239 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
240 Mockito.when(searchService.searchUserByUserId(orgUserIdStr)).thenReturn(user);
241 fnMenuStaticactualResponse = functionalMenuController.getFunctionalMenuStaticInfo(mockedRequest, mockedResponse);
243 assertEquals(fnMenuStaticactualResponse, fnMenuStaticexpectedResponse);
248 public void getFunctionalMenuStaticInfoTest(){
249 String fnMenuStaticactualResponse = null;
250 String fnMenuStaticexpectedResponse = "{\"firstName\":\"test\",\"lastName\":\"test\",\"last_login\":\"09/08/2017 03:48:13 -0400 am\",\"userId\":\"guestT\",\"email\":\"test\"}";
251 String orgUserIdStr = null;
253 EPUser user = mockUser.mockEPUser();
254 user.setEmail("test");
255 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
256 Mockito.when(searchService.searchUserByUserId(orgUserIdStr)).thenReturn(user);
257 fnMenuStaticactualResponse = functionalMenuController.getFunctionalMenuStaticInfo(mockedRequest, mockedResponse);
258 assertEquals(fnMenuStaticactualResponse.length(), fnMenuStaticexpectedResponse.length());
262 public void getMenuItemsForAuthUserNullTest(){
263 List<FunctionalMenuItem> actualmenuItems = null;
264 List<FunctionalMenuItem> expectedmenuItems = null;
266 actualmenuItems = functionalMenuController.getMenuItemsForAuthUser(mockedRequest, mockedResponse);
267 assertEquals(actualmenuItems, expectedmenuItems);
271 public void getMenuItemsForAuthUserIsSuperAdminTest(){
272 List<FunctionalMenuItem> actualmenuItems = null;
273 List<FunctionalMenuItem> expectedmenuItems = new ArrayList<FunctionalMenuItem>();
274 EPUser user = mockUser.mockEPUser();
275 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
276 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
278 actualmenuItems = functionalMenuController.getMenuItemsForAuthUser(mockedRequest, mockedResponse);
279 assertEquals(actualmenuItems, expectedmenuItems);
283 public void getMenuItemsForAuthUserTest(){
284 List<FunctionalMenuItem> actualmenuItems = null;
285 List<FunctionalMenuItem> expectedmenuItems = new ArrayList<FunctionalMenuItem>();
286 EPUser user = mockUser.mockEPUser();
287 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
288 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
290 actualmenuItems = functionalMenuController.getMenuItemsForAuthUser(mockedRequest, mockedResponse);
291 assertEquals(actualmenuItems, expectedmenuItems);
295 public void getFunctionalMenuItemDetailsBadPermissionTest(){
297 FunctionalMenuItem actualmenuItem = null;
298 FunctionalMenuItem expectedmenuItem = null;
299 EPUser user = mockUser.mockEPUser();
300 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
302 actualmenuItem = functionalMenuController.getFunctionalMenuItemDetails(mockedRequest, menuId, mockedResponse);
303 assertEquals(actualmenuItem, expectedmenuItem);
307 public void getFunctionalMenuItemDetailsExceptionTest(){
309 FunctionalMenuItem actualmenuItem = null;
310 FunctionalMenuItem expectedmenuItem = null;
311 EPUser user = mockUser.mockEPUser();
312 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
313 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
314 Mockito.when(functionalMenuService.getFunctionalMenuItemDetails(menuId)).thenThrow(nullPointerException);
316 actualmenuItem = functionalMenuController.getFunctionalMenuItemDetails(mockedRequest, menuId, mockedResponse);
317 assertEquals(actualmenuItem, expectedmenuItem);
321 public void getFunctionalMenuItemDetailsTest(){
323 FunctionalMenuItem actualmenuItem = null;
324 FunctionalMenuItem expectedmenuItem = null;
325 EPUser user = mockUser.mockEPUser();
326 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
327 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
328 Mockito.when(functionalMenuService.getFunctionalMenuItemDetails(menuId)).thenReturn(actualmenuItem);
330 actualmenuItem = functionalMenuController.getFunctionalMenuItemDetails(mockedRequest, menuId, mockedResponse);
331 assertEquals(actualmenuItem, expectedmenuItem);
335 public void getMenuItemsForEditingTest(){
336 List<FunctionalMenuItem> actualMenuItems = null;
337 List<FunctionalMenuItem> expectedMenuItems = null;
338 EPUser user = mockUser.mockEPUser();
339 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
340 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
341 Mockito.when(functionalMenuService.getFunctionalMenuItems(true)).thenReturn(actualMenuItems);
343 actualMenuItems = functionalMenuController.getMenuItemsForEditing(mockedRequest, mockedResponse);
344 assertEquals(actualMenuItems, expectedMenuItems);
348 public void getMenuItemsForEditingBadPermissionsTest(){
349 List<FunctionalMenuItem> actualMenuItems = null;
350 List<FunctionalMenuItem> expectedMenuItems = null;
351 EPUser user = mockUser.mockEPUser();
352 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
353 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
354 Mockito.when(functionalMenuService.getFunctionalMenuItems(true)).thenReturn(actualMenuItems);
356 actualMenuItems = functionalMenuController.getMenuItemsForEditing(mockedRequest, mockedResponse);
357 assertEquals(actualMenuItems, expectedMenuItems);
361 public void getMenuItemsForEditingExceptionTest(){
362 List<FunctionalMenuItem> actualMenuItems = null;
363 List<FunctionalMenuItem> expectedMenuItems = null;
364 EPUser user = mockUser.mockEPUser();
365 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
366 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
367 Mockito.when(functionalMenuService.getFunctionalMenuItems(true)).thenThrow(nullPointerException);
368 actualMenuItems = functionalMenuController.getMenuItemsForEditing(mockedRequest, mockedResponse);
369 assertEquals(actualMenuItems, expectedMenuItems);
373 public void getMenuItemsForNotificationsExceptionTest(){
374 List<FunctionalMenuItem> actualMenuItems = null;
375 List<FunctionalMenuItem> expectedMenuItems = null;
376 Mockito.when(functionalMenuService.getFunctionalMenuItemsForNotificationTree(true)).thenThrow(nullPointerException);
378 actualMenuItems = functionalMenuController.getMenuItemsForNotifications(mockedRequest, mockedResponse);
379 assertEquals(actualMenuItems, expectedMenuItems);
382 public void getMenuItemsForNotificationsTest(){
383 List<FunctionalMenuItem> actualMenuItems = null;
384 List<FunctionalMenuItem> expectedMenuItems = new ArrayList<FunctionalMenuItem>();
385 Mockito.when(functionalMenuService.getFunctionalMenuItemsForNotificationTree(false)).thenReturn(actualMenuItems);
387 actualMenuItems = functionalMenuController.getMenuItemsForNotifications(mockedRequest, mockedResponse);
388 assertEquals(actualMenuItems, expectedMenuItems);
392 public void getMenuItemsForAppTest(){
393 Integer appId = 1234;
394 List<FunctionalMenuItem> actualMenuItems = null;
395 List<FunctionalMenuItem> expectedMenuItems = null;
396 Mockito.when(functionalMenuService.getFunctionalMenuItemsForApp(appId)).thenReturn(actualMenuItems);
398 actualMenuItems = functionalMenuController.getMenuItemsForApp(mockedRequest, appId);
399 assertEquals(actualMenuItems, expectedMenuItems);
403 public void getMenuItemsForAppExceptionTest(){
404 Integer appId = 1234;
405 List<FunctionalMenuItem> actualMenuItems = null;
406 List<FunctionalMenuItem> expectedMenuItems = null;
407 Mockito.when(functionalMenuService.getFunctionalMenuItemsForApp(appId)).thenThrow(nullPointerException);
409 actualMenuItems = functionalMenuController.getMenuItemsForApp(mockedRequest, appId);
410 assertEquals(actualMenuItems, expectedMenuItems);
414 public void getMenuItemsForUserTest(){
415 String orgUserId ="test";
416 List<FunctionalMenuItem> actualMenuItems = null;
417 List<FunctionalMenuItem> expectedMenuItems = null;
418 Mockito.when(functionalMenuService.getFunctionalMenuItemsForUser(orgUserId)).thenReturn(actualMenuItems);
420 actualMenuItems = functionalMenuController.getMenuItemsForUser(mockedRequest, orgUserId);
421 assertEquals(actualMenuItems, expectedMenuItems);
425 public void getMenuItemsForUserExceptionTest(){
426 String orgUserId ="test";
427 List<FunctionalMenuItem> actualMenuItems = null;
428 List<FunctionalMenuItem> expectedMenuItems = null;
429 Mockito.when(functionalMenuService.getFunctionalMenuItemsForUser(orgUserId)).thenThrow(nullPointerException);
431 actualMenuItems = functionalMenuController.getMenuItemsForUser(mockedRequest, orgUserId);
432 assertEquals(actualMenuItems, expectedMenuItems);
436 public void createFunctionalMenuItemTest(){
437 FieldsValidator actualFieldsValidator = new FieldsValidator();
438 FieldsValidator expectedFieldsValidator = new FieldsValidator();
439 List<FieldName> fields = new ArrayList<>();
440 expectedFieldsValidator.setHttpStatusCode((long) 200);
441 expectedFieldsValidator.setFields(fields);
442 expectedFieldsValidator.setErrorCode(null);
443 FunctionalMenuItemWithRoles menuItemJson = new FunctionalMenuItemWithRoles();
444 EPUser user = mockUser.mockEPUser();
445 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
446 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
447 Mockito.when(functionalMenuService.createFunctionalMenuItem(menuItemJson)).thenReturn(expectedFieldsValidator);
448 actualFieldsValidator = functionalMenuController.createFunctionalMenuItem(mockedRequest, menuItemJson, mockedResponse);
449 assertEquals(actualFieldsValidator, expectedFieldsValidator);
453 public void createFunctionalMenuItemBadPermisssionsTest(){
454 FieldsValidator actualFieldsValidator = null;
455 FieldsValidator expectedFieldsValidator = null;
456 FunctionalMenuItemWithRoles menuItemJson = new FunctionalMenuItemWithRoles();
457 EPUser user = mockUser.mockEPUser();
458 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
459 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
460 Mockito.when(functionalMenuService.createFunctionalMenuItem(menuItemJson)).thenReturn(expectedFieldsValidator);
461 actualFieldsValidator = functionalMenuController.createFunctionalMenuItem(mockedRequest, menuItemJson, mockedResponse);
462 assertEquals(actualFieldsValidator, expectedFieldsValidator);
466 public void getFavoritesForUserTest(){
467 List<FavoritesFunctionalMenuItemJson> actualFavoritesFunctionalMenuItemsJson = null;
468 List<FavoritesFunctionalMenuItemJson> expectedFunctionalMenuItemsJson = new ArrayList<FavoritesFunctionalMenuItemJson>();
469 EPUser user = mockUser.mockEPUser();
470 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
471 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
472 Mockito.when(functionalMenuService.getFavoriteItems(user.getId())).thenReturn(expectedFunctionalMenuItemsJson);
473 actualFavoritesFunctionalMenuItemsJson = functionalMenuController.getFavoritesForUser(mockedRequest, mockedResponse);
474 assertEquals(actualFavoritesFunctionalMenuItemsJson, expectedFunctionalMenuItemsJson);
478 public void deleteFavoriteItemTest(){
479 Long userId = (long)1;
480 Long menuId = (long)1;
481 FieldsValidator actualFieldsValidator = new FieldsValidator();
482 FieldsValidator expectedFieldsValidator = new FieldsValidator();
483 List<FieldName> fields = new ArrayList<>();
484 expectedFieldsValidator.setHttpStatusCode((long) 200);
485 expectedFieldsValidator.setFields(fields);
486 expectedFieldsValidator.setErrorCode(null);
487 EPUser user = mockUser.mockEPUser();
488 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
489 Mockito.when(functionalMenuService.removeFavoriteItem(user.getId(), menuId)).thenReturn(actualFieldsValidator);
490 actualFieldsValidator = functionalMenuController.deleteFavoriteItem(mockedRequest, menuId, mockedResponse);
491 assertEquals(actualFieldsValidator, expectedFieldsValidator);
495 public void addFavoriteItemTest(){
496 FavoritesFunctionalMenuItem menuItemJson = new FavoritesFunctionalMenuItem();
497 FieldsValidator actualFieldsValidator = new FieldsValidator();
498 FieldsValidator expectedFieldsValidator = new FieldsValidator();
499 List<FieldName> fields = new ArrayList<>();
500 expectedFieldsValidator.setHttpStatusCode((long) 200);
501 expectedFieldsValidator.setFields(fields);
502 expectedFieldsValidator.setErrorCode(null);
503 EPUser user = mockUser.mockEPUser();
504 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
505 Mockito.when(functionalMenuService.setFavoriteItem(menuItemJson)).thenReturn(actualFieldsValidator);
506 actualFieldsValidator = functionalMenuController.addFavoriteItem(mockedRequest, menuItemJson, mockedResponse);
507 assertEquals(actualFieldsValidator, expectedFieldsValidator);
511 public void getMenuItemsTest(){
512 List<FunctionalMenuItem> actualFunctionalMenuItems = new ArrayList<FunctionalMenuItem>();
513 List<FunctionalMenuItem> expectedFunctionalMenuItems = new ArrayList<FunctionalMenuItem>();
514 List<FunctionalMenuItem> menuItems = new ArrayList<FunctionalMenuItem>();
515 Mockito.when(functionalMenuService.getFunctionalMenuItems()).thenReturn(menuItems);
516 actualFunctionalMenuItems = functionalMenuController.getMenuItems(mockedRequest, mockedResponse);
517 assertEquals(actualFunctionalMenuItems, expectedFunctionalMenuItems);
521 public void deleteFunctionalMenuItemTest(){
522 Long menuId = (long)1;
523 FieldsValidator actualFieldsValidator = new FieldsValidator();
524 FieldsValidator expectedFieldsValidator = new FieldsValidator();
525 List<FieldName> fields = new ArrayList<>();
526 expectedFieldsValidator.setHttpStatusCode((long) 200);
527 expectedFieldsValidator.setFields(fields);
528 expectedFieldsValidator.setErrorCode(null);
529 EPUser user = mockUser.mockEPUser();
530 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
531 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
532 Mockito.when(functionalMenuService.deleteFunctionalMenuItem(menuId)).thenReturn(actualFieldsValidator);
533 actualFieldsValidator = functionalMenuController.deleteFunctionalMenuItem(mockedRequest, menuId, mockedResponse);
534 assertEquals(actualFieldsValidator, expectedFieldsValidator);
538 public void deleteFunctionalMenuItemBadPermissionsTest(){
539 Long menuId = (long)1;
540 FieldsValidator actualFieldsValidator = null;
541 FieldsValidator expectedFieldsValidator = null;
542 EPUser user = mockUser.mockEPUser();
543 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
544 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
545 Mockito.when(functionalMenuService.deleteFunctionalMenuItem(menuId)).thenReturn(actualFieldsValidator);
546 actualFieldsValidator = functionalMenuController.deleteFunctionalMenuItem(mockedRequest, menuId, mockedResponse);
547 assertEquals(actualFieldsValidator, expectedFieldsValidator);
551 public void editFunctionalMenuItemTest(){
552 FunctionalMenuItemWithRoles menuItemJson = new FunctionalMenuItemWithRoles();
553 FieldsValidator actualFieldsValidator = new FieldsValidator();
554 FieldsValidator expectedFieldsValidator = new FieldsValidator();
555 List<FieldName> fields = new ArrayList<>();
556 expectedFieldsValidator.setHttpStatusCode((long) 200);
557 expectedFieldsValidator.setFields(fields);
558 expectedFieldsValidator.setErrorCode(null);
559 EPUser user = mockUser.mockEPUser();
560 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
561 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
562 Mockito.when(functionalMenuService.editFunctionalMenuItem(menuItemJson)).thenReturn(actualFieldsValidator);
563 actualFieldsValidator = functionalMenuController.editFunctionalMenuItem(mockedRequest, menuItemJson, mockedResponse);
564 assertEquals(actualFieldsValidator, expectedFieldsValidator);
568 public void editFunctionalMenuItemBadPermissionsTest(){
569 FunctionalMenuItemWithRoles menuItemJson = new FunctionalMenuItemWithRoles();
570 FieldsValidator actualFieldsValidator = null;
571 FieldsValidator expectedFieldsValidator = null;
572 EPUser user = mockUser.mockEPUser();
573 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
574 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
575 Mockito.when(functionalMenuService.editFunctionalMenuItem(menuItemJson)).thenReturn(actualFieldsValidator);
576 actualFieldsValidator = functionalMenuController.editFunctionalMenuItem(mockedRequest, menuItemJson, mockedResponse);
577 assertEquals(actualFieldsValidator, expectedFieldsValidator);
581 public void getECOMPTitleTest(){
582 PortalRestResponse<String> actualportalRestResponse = null;
583 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
584 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
585 expectedportalRestResponse.setMessage("success");
586 expectedportalRestResponse.setResponse("Portal");
587 PowerMockito.mockStatic(SystemProperties.class);
588 Mockito.when(SystemProperties.getProperty(SystemProperties.APP_DISPLAY_NAME)).thenReturn("Portal");
589 actualportalRestResponse = functionalMenuController.getECOMPTitle(mockedRequest, mockedResponse);
590 assertEquals(actualportalRestResponse, expectedportalRestResponse);
594 public void getECOMPTitleExceptionTest(){
595 PortalRestResponse<String> actualportalRestResponse = null;
596 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
597 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
598 expectedportalRestResponse.setMessage(null);
599 expectedportalRestResponse.setResponse(null);
600 PowerMockito.mockStatic(SystemProperties.class);
602 Mockito.when(SystemProperties.getProperty(SystemProperties.APP_DISPLAY_NAME)).thenThrow(nullPointerException);
603 actualportalRestResponse = functionalMenuController.getECOMPTitle(mockedRequest, mockedResponse);
604 assertEquals(actualportalRestResponse, expectedportalRestResponse);