ecomp-portal-BE-common/src/test/java/org/onap/portalapp/portal/controller/FunctionalMenuControllerTest.java

   1 /*-
   2  * ============LICENSE_START==========================================
   3  * ONAP Portal
   4  * ===================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ===================================================================
   7  *
   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
  12  *
  13  *             http://www.apache.org/licenses/LICENSE-2.0
  14  *
  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.
  20  *
  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
  25  *
  26  *             https://creativecommons.org/licenses/by/4.0/
  27  *
  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.
  33  *
  34  * ============LICENSE_END============================================
  35  *
  36  *
  37  */
  38 package org.onap.portalapp.portal.controller;
  39
  40 import static org.junit.Assert.assertEquals;
  41 import static org.junit.Assert.assertNull;
  42 import static org.junit.Assert.assertTrue;
  43
  44 import java.io.IOException;
  45 import java.io.PrintWriter;
  46 import java.util.ArrayList;
  47 import java.util.List;
  48
  49 import javax.servlet.http.HttpServletRequest;
  50 import javax.servlet.http.HttpServletResponse;
  51 import javax.servlet.http.HttpSession;
  52
  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;
  86
  87 @RunWith(PowerMockRunner.class)
  88 @PrepareForTest(SystemProperties.class)
  89 public class FunctionalMenuControllerTest extends MockitoTestSuite {
  90
  91         String userid = "ab1234";
  92
  93         @Mock
  94         FunctionalMenuService functionalMenuService = new FunctionalMenuServiceImpl();
  95
  96         @InjectMocks
  97         FunctionalMenuController functionalMenuController = new FunctionalMenuController();
  98
  99         @Mock
 100         private DataAccessService dataAccessService;
 101
 102         @Mock
 103         SearchService searchService;
 104
 105         @Mock
 106         AdminRolesService adminRolesService = new AdminRolesServiceImpl();
 107
 108         NullPointerException nullPointerException = new NullPointerException();
 109
 110         @Before
 111         public void setup() {
 112                 MockitoAnnotations.initMocks(this);
 113         }
 114
 115         MockitoTestSuite mockitoTestSuite = new MockitoTestSuite();
 116
 117         HttpServletRequest mockedRequest = mockitoTestSuite.getMockedRequest();
 118         HttpServletResponse mockedResponse = mockitoTestSuite.getMockedResponse();
 119
 120         @InjectMocks
 121         EPUserUtils ePUserUtils = new EPUserUtils();
 122
 123         @Mock
 124         EPUser epuser;
 125
 126         MockEPUser mockUser = new MockEPUser();
 127
 128         List<BusinessCardApplicationRolesList> appRoles = new ArrayList<BusinessCardApplicationRolesList>();
 129         List<BusinessCardApplicationRolesList> appRolesActual = new ArrayList<BusinessCardApplicationRolesList>();
 130
 131         List<BusinessCardApplicationRole> userAppRoleList = new ArrayList<BusinessCardApplicationRole>();
 132
 133         public List<BusinessCardApplicationRole> mockBusinessCardApplicationRole() {
 134                 List<BusinessCardApplicationRole> userAppRoleList = new ArrayList<BusinessCardApplicationRole>();
 135
 136                 BusinessCardApplicationRole businessCardApplicationRole = new BusinessCardApplicationRole();
 137                 businessCardApplicationRole.setRoleName("ADMIN");
 138                 businessCardApplicationRole.setAppName("ASDC");
 139
 140                 BusinessCardApplicationRole businessCardApplicationRole1 = new BusinessCardApplicationRole();
 141                 businessCardApplicationRole1.setAppName("ASDC");
 142                 businessCardApplicationRole1.setRoleName("Tester");
 143
 144                 userAppRoleList.add(businessCardApplicationRole);
 145                 userAppRoleList.add(businessCardApplicationRole1);
 146                 return userAppRoleList;
 147         }
 148
 149         public List<BusinessCardApplicationRolesList> mockBusinessCardApplicationRolesList() {
 150                 List<BusinessCardApplicationRolesList> appRolesActual = new ArrayList<BusinessCardApplicationRolesList>();
 151
 152                 BusinessCardApplicationRolesList businessCardApplicationRolesList = new BusinessCardApplicationRolesList();
 153                 businessCardApplicationRolesList.setAppName("ASDC");
 154
 155                 List<String> roleNames = new ArrayList<String>();
 156                 roleNames.add("ADMIN");
 157                 roleNames.add("Tester");
 158                 businessCardApplicationRolesList.setRoleNames(roleNames);
 159
 160                 appRolesActual.add(businessCardApplicationRolesList);
 161                 return appRolesActual;
 162         }
 163
 164         @Test
 165         public void getAppListTestIfAppAlredyExistsBusinessCardApplicationRolesList() throws IOException {
 166
 167                 userAppRoleList = mockBusinessCardApplicationRole();
 168                 appRolesActual = mockBusinessCardApplicationRolesList();
 169
 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);
 174
 175                 appRoles = functionalMenuController.getAppList(mockedRequest, mockedResponse, userid);
 176
 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());
 180
 181         }
 182
 183         @Test
 184         public void getAppListTestForOtherUser() throws IOException {
 185
 186                 userAppRoleList = mockBusinessCardApplicationRole();
 187                 appRolesActual = mockBusinessCardApplicationRolesList();
 188
 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));
 194
 195                 appRoles = functionalMenuController.getAppList(mockedRequest, mockedResponse, userid);
 196                 assertNull(appRoles);
 197                 assertEquals(0, mockedResponse.getStatus());
 198
 199
 200         }
 201
 202                 @Test
 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);
 218         }
 219
 220         @Test
 221         public void getAppListTestIfAppDoesnotExistsInBusinessCardApplicationRolesList() throws IOException {
 222
 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());
 245
 246         }
 247
 248         @Test
 249         public void regenerateAncestorTableTest() {
 250                 EPUser user = mockUser.mockEPUser();
 251
 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));
 265         }
 266
 267         @Test
 268         public void getMenuItemsExceptionTest(){
 269                 List<FunctionalMenuItem> actualmenuItems = null;
 270                 List<FunctionalMenuItem> expectedmenuItems = null;
 271
 272                 Mockito.when(functionalMenuController.getMenuItemsForAuthUser(mockedRequest, mockedResponse)).thenThrow(nullPointerException);
 273                 actualmenuItems = functionalMenuController.getMenuItemsForAuthUser(mockedRequest, mockedResponse);
 274                 assertEquals(actualmenuItems, expectedmenuItems);
 275         }
 276
 277         @Test
 278         public void getFunctionalMenuStaticInfoExceptionTest(){
 279                 String fnMenuStaticactualResponse = null;
 280                 String fnMenuStaticexpectedResponse = null;
 281                 String orgUserIdStr = null;
 282
 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);
 287
 288                 assertEquals(fnMenuStaticactualResponse, fnMenuStaticexpectedResponse);
 289
 290         }
 291
 292         @Test
 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;
 297
 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());
 304         }
 305
 306         @Test
 307         public void getMenuItemsForAuthUserNullTest(){
 308                 List<FunctionalMenuItem> actualmenuItems = null;
 309                 List<FunctionalMenuItem> expectedmenuItems = null;
 310
 311                 actualmenuItems = functionalMenuController.getMenuItemsForAuthUser(mockedRequest, mockedResponse);
 312                 assertEquals(actualmenuItems, expectedmenuItems);
 313         }
 314
 315         @Test
 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);
 322
 323                 actualmenuItems = functionalMenuController.getMenuItemsForAuthUser(mockedRequest, mockedResponse);
 324                 assertEquals(actualmenuItems, expectedmenuItems);
 325         }
 326
 327         @Test
 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);
 334
 335                 actualmenuItems = functionalMenuController.getMenuItemsForAuthUser(mockedRequest, mockedResponse);
 336                 assertEquals(actualmenuItems, expectedmenuItems);
 337         }
 338
 339         @Test
 340         public void getFunctionalMenuItemDetailsBadPermissionTest(){
 341                 Long menuId = 1234L;
 342                 FunctionalMenuItem actualmenuItem = null;
 343                 FunctionalMenuItem expectedmenuItem = null;
 344                 EPUser user = mockUser.mockEPUser();
 345                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 346
 347                 actualmenuItem = functionalMenuController.getFunctionalMenuItemDetails(mockedRequest, menuId, mockedResponse);
 348                 assertEquals(actualmenuItem, expectedmenuItem);
 349         }
 350
 351         @Test
 352         public void getFunctionalMenuItemDetailsExceptionTest(){
 353                 Long menuId = 1234L;
 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);
 360
 361                 actualmenuItem = functionalMenuController.getFunctionalMenuItemDetails(mockedRequest, menuId, mockedResponse);
 362                 assertEquals(actualmenuItem, expectedmenuItem);
 363         }
 364
 365         @Test
 366         public void getFunctionalMenuItemDetailsTest(){
 367                 Long menuId = 1234L;
 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);
 374
 375                 actualmenuItem = functionalMenuController.getFunctionalMenuItemDetails(mockedRequest, menuId, mockedResponse);
 376                 assertEquals(actualmenuItem, expectedmenuItem);
 377         }
 378
 379         @Test
 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);
 387
 388                 actualMenuItems = functionalMenuController.getMenuItemsForEditing(mockedRequest, mockedResponse);
 389                 assertEquals(actualMenuItems, expectedMenuItems);
 390         }
 391
 392         @Test
 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);
 400
 401                 actualMenuItems = functionalMenuController.getMenuItemsForEditing(mockedRequest, mockedResponse);
 402                 assertEquals(actualMenuItems, expectedMenuItems);
 403         }
 404
 405         @Test
 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);
 415         }
 416
 417         @Test
 418         public void getMenuItemsForNotificationsExceptionTest(){
 419                 List<FunctionalMenuItem> actualMenuItems = null;
 420                 List<FunctionalMenuItem> expectedMenuItems = null;
 421                 Mockito.when(functionalMenuService.getFunctionalMenuItemsForNotificationTree(true)).thenThrow(nullPointerException);
 422
 423                 actualMenuItems = functionalMenuController.getMenuItemsForNotifications(mockedRequest, mockedResponse);
 424                 assertEquals(actualMenuItems, expectedMenuItems);
 425         }
 426         @Test
 427         public void getMenuItemsForNotificationsTest(){
 428                 List<FunctionalMenuItem> actualMenuItems = null;
 429                 List<FunctionalMenuItem> expectedMenuItems = new ArrayList<FunctionalMenuItem>();
 430                 Mockito.when(functionalMenuService.getFunctionalMenuItemsForNotificationTree(false)).thenReturn(actualMenuItems);
 431
 432                 actualMenuItems = functionalMenuController.getMenuItemsForNotifications(mockedRequest, mockedResponse);
 433                 assertEquals(actualMenuItems, expectedMenuItems);
 434         }
 435
 436         @Test
 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);
 442
 443                 actualMenuItems = functionalMenuController.getMenuItemsForApp(mockedRequest, appId);
 444                 assertEquals(actualMenuItems, expectedMenuItems);
 445         }
 446
 447         @Test
 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);
 453
 454                 actualMenuItems = functionalMenuController.getMenuItemsForApp(mockedRequest, appId);
 455                 assertEquals(actualMenuItems, expectedMenuItems);
 456         }
 457
 458         @Test
 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);
 464
 465                 actualMenuItems = functionalMenuController.getMenuItemsForUser(mockedRequest, orgUserId);
 466                 assertEquals(actualMenuItems, expectedMenuItems);
 467         }
 468
 469         @Test
 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);
 475
 476                 actualMenuItems = functionalMenuController.getMenuItemsForUser(mockedRequest, orgUserId);
 477                 assertEquals(actualMenuItems, expectedMenuItems);
 478         }
 479
 480         @Test
 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);
 495         }
 496
 497         @Test
 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);
 508         }
 509
 510         @Test
 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);
 520         }
 521
 522         @Test
 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);
 537         }
 538
 539         @Test
 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);
 553         }
 554
 555         @Test
 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);
 563         }
 564
 565         @Test
 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);
 580         }
 581
 582         @Test
 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);
 593         }
 594
 595         @Test
 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);
 610         }
 611
 612         @Test
 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);
 623         }
 624
 625         @Test
 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);
 636         }
 637
 638         @Test
 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);
 646
 647                 Mockito.when(SystemProperties.getProperty(SystemProperties.APP_DISPLAY_NAME)).thenThrow(nullPointerException);
 648                 actualportalRestResponse = functionalMenuController.getECOMPTitle(mockedRequest, mockedResponse);
 649                 assertEquals(actualportalRestResponse, expectedportalRestResponse);
 650         }
 651
 652 }