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

   1 /*-
   2  * ================================================================================
   3  * ECOMP Portal
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ================================================================================
  19  */
  20 package org.openecomp.portalapp.portal.test.controller;
  21
  22 import static org.junit.Assert.assertEquals;
  23 import static org.junit.Assert.assertTrue;
  24
  25 import java.io.IOException;
  26 import java.util.ArrayList;
  27 import java.util.List;
  28
  29 import javax.servlet.http.HttpServletRequest;
  30 import javax.servlet.http.HttpServletResponse;
  31 import javax.servlet.http.HttpSession;
  32
  33 import org.junit.Before;
  34 import org.junit.Test;
  35 import org.junit.runner.RunWith;
  36 import org.mockito.InjectMocks;
  37 import org.mockito.Mock;
  38 import org.mockito.Mockito;
  39 import org.mockito.MockitoAnnotations;
  40 import org.mockito.runners.MockitoJUnitRunner;
  41 import org.openecomp.portalapp.portal.controller.FunctionalMenuController;
  42 import org.openecomp.portalapp.portal.domain.EPUser;
  43 import org.openecomp.portalapp.portal.ecomp.model.PortalRestResponse;
  44 import org.openecomp.portalapp.portal.ecomp.model.PortalRestStatusEnum;
  45 import org.openecomp.portalapp.portal.service.AdminRolesService;
  46 import org.openecomp.portalapp.portal.service.AdminRolesServiceImpl;
  47 import org.openecomp.portalapp.portal.service.FunctionalMenuService;
  48 import org.openecomp.portalapp.portal.service.FunctionalMenuServiceImpl;
  49 import org.openecomp.portalapp.portal.service.SearchService;
  50 import org.openecomp.portalapp.portal.test.core.MockEPUser;
  51 import org.openecomp.portalapp.portal.test.framework.MockitoTestSuite;
  52 import org.openecomp.portalapp.portal.transport.BusinessCardApplicationRole;
  53 import org.openecomp.portalapp.portal.transport.BusinessCardApplicationRolesList;
  54 import org.openecomp.portalapp.portal.transport.FavoritesFunctionalMenuItem;
  55 import org.openecomp.portalapp.portal.transport.FavoritesFunctionalMenuItemJson;
  56 import org.openecomp.portalapp.portal.transport.FieldsValidator;
  57 import org.openecomp.portalapp.portal.transport.FieldsValidator.FieldName;
  58 import org.openecomp.portalapp.portal.transport.FunctionalMenuItem;
  59 import org.openecomp.portalapp.portal.transport.FunctionalMenuItemWithRoles;
  60 import org.openecomp.portalapp.util.EPUserUtils;
  61 import org.openecomp.portalsdk.core.service.DataAccessService;
  62 import org.openecomp.portalsdk.core.util.SystemProperties;
  63 import org.powermock.api.mockito.PowerMockito;
  64 import org.powermock.core.classloader.annotations.PrepareForTest;
  65 import org.powermock.modules.junit4.PowerMockRunner;
  66
  67 @RunWith(PowerMockRunner.class)
  68 @PrepareForTest(SystemProperties.class)
  69 public class FunctionalMenuControllerTest extends MockitoTestSuite {
  70
  71         String userid = "ab1234";
  72
  73         @Mock
  74         FunctionalMenuService functionalMenuService = new FunctionalMenuServiceImpl();
  75
  76         @InjectMocks
  77         FunctionalMenuController functionalMenuController = new FunctionalMenuController();
  78
  79         @Mock
  80         private DataAccessService dataAccessService;
  81
  82         @Mock
  83         SearchService searchService;
  84
  85         @Mock
  86         AdminRolesService adminRolesService = new AdminRolesServiceImpl();
  87
  88         @Before
  89         public void setup() {
  90                 MockitoAnnotations.initMocks(this);
  91         }
  92
  93         MockitoTestSuite mockitoTestSuite = new MockitoTestSuite();
  94
  95         HttpServletRequest mockedRequest = mockitoTestSuite.getMockedRequest();
  96         HttpServletResponse mockedResponse = mockitoTestSuite.getMockedResponse();
  97
  98         @InjectMocks
  99         EPUserUtils ePUserUtils = new EPUserUtils();
 100
 101         @Mock
 102         EPUser epuser;
 103
 104         MockEPUser mockUser = new MockEPUser();
 105
 106         List<BusinessCardApplicationRolesList> appRoles = new ArrayList<BusinessCardApplicationRolesList>();
 107         List<BusinessCardApplicationRolesList> appRolesActual = new ArrayList<BusinessCardApplicationRolesList>();
 108
 109         List<BusinessCardApplicationRole> userAppRoleList = new ArrayList<BusinessCardApplicationRole>();
 110
 111         public List<BusinessCardApplicationRole> mockBusinessCardApplicationRole() {
 112                 List<BusinessCardApplicationRole> userAppRoleList = new ArrayList<BusinessCardApplicationRole>();
 113
 114                 BusinessCardApplicationRole businessCardApplicationRole = new BusinessCardApplicationRole();
 115                 businessCardApplicationRole.setRoleName("ADMIN");
 116                 businessCardApplicationRole.setAppName("ASDC");
 117
 118                 BusinessCardApplicationRole businessCardApplicationRole1 = new BusinessCardApplicationRole();
 119                 businessCardApplicationRole1.setAppName("ASDC");
 120                 businessCardApplicationRole1.setRoleName("Tester");
 121
 122                 userAppRoleList.add(businessCardApplicationRole);
 123                 userAppRoleList.add(businessCardApplicationRole1);
 124                 return userAppRoleList;
 125         }
 126
 127         public List<BusinessCardApplicationRolesList> mockBusinessCardApplicationRolesList() {
 128                 List<BusinessCardApplicationRolesList> appRolesActual = new ArrayList<BusinessCardApplicationRolesList>();
 129
 130                 BusinessCardApplicationRolesList businessCardApplicationRolesList = new BusinessCardApplicationRolesList();
 131                 businessCardApplicationRolesList.setAppName("ASDC");
 132
 133                 List<String> roleNames = new ArrayList<String>();
 134                 roleNames.add("ADMIN");
 135                 roleNames.add("Tester");
 136                 businessCardApplicationRolesList.setRoleNames(roleNames);
 137
 138                 appRolesActual.add(businessCardApplicationRolesList);
 139                 return appRolesActual;
 140         }
 141
 142         @Test
 143         public void getAppListTestIfAppAlredyExistsBusinessCardApplicationRolesList() throws IOException {
 144
 145                 userAppRoleList = mockBusinessCardApplicationRole();
 146                 appRolesActual = mockBusinessCardApplicationRolesList();
 147
 148                 Mockito.when(functionalMenuService.getUserAppRolesList(userid)).thenReturn(userAppRoleList);
 149
 150                 appRoles = functionalMenuController.getAppList(mockedRequest, userid);
 151
 152                 assertEquals(appRolesActual.size(), appRoles.size());
 153                 assertEquals(appRolesActual.get(0).getAppName(), appRoles.get(0).getAppName());
 154                 assertEquals(appRolesActual.get(0).getRoleNames(), appRoles.get(0).getRoleNames());
 155
 156         }
 157
 158         @Test
 159         public void getAppListTestIfAppDoesnotExistsInBusinessCardApplicationRolesList() throws IOException {
 160
 161                 userAppRoleList = mockBusinessCardApplicationRole();
 162                 BusinessCardApplicationRole businessCardApplicationRole = new BusinessCardApplicationRole();
 163                 businessCardApplicationRole.setAppName("CCD");
 164                 businessCardApplicationRole.setRoleName("ADMIN");
 165                 userAppRoleList.add(businessCardApplicationRole);
 166                 appRolesActual = mockBusinessCardApplicationRolesList();
 167                 BusinessCardApplicationRolesList businessCardApplicationRolesList = new BusinessCardApplicationRolesList();
 168                 businessCardApplicationRolesList.setAppName("CCD");
 169                 List<String> roleNames1 = new ArrayList<String>();
 170                 roleNames1.add("ADMIN");
 171                 businessCardApplicationRolesList.setRoleNames(roleNames1);
 172                 appRolesActual.add(businessCardApplicationRolesList);
 173                 Mockito.when(functionalMenuService.getUserAppRolesList(userid)).thenReturn(userAppRoleList);
 174                 appRoles = functionalMenuController.getAppList(mockedRequest, userid);
 175                 assertEquals(appRolesActual.size(), appRoles.size());
 176                 assertEquals(appRolesActual.get(0).getAppName(), appRoles.get(0).getAppName());
 177                 assertEquals(appRolesActual.get(0).getRoleNames(), appRoles.get(0).getRoleNames());
 178                 assertEquals(appRolesActual.get(1).getAppName(), appRoles.get(1).getAppName());
 179                 assertEquals(appRolesActual.get(1).getRoleNames(), appRoles.get(1).getRoleNames());
 180
 181         }
 182
 183         @Test
 184         public void regenerateAncestorTableTest() {
 185                 EPUser user = mockUser.mockEPUser();
 186
 187                 HttpSession session = mockedRequest.getSession();
 188                 session.setAttribute(SystemProperties.getProperty(SystemProperties.USER_ATTRIBUTE_NAME), user);
 189                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 190                 FieldsValidator acutualFieldValidator = null;
 191                 FieldsValidator expectedFieldValidator = new FieldsValidator();
 192                 List<FieldName> fields = new ArrayList<>();
 193                 expectedFieldValidator.setHttpStatusCode((long) 200);
 194                 expectedFieldValidator.setFields(fields);
 195                 expectedFieldValidator.setErrorCode(null);
 196                 Mockito.when(!adminRolesService.isSuperAdmin(user)).thenReturn(true);
 197                 Mockito.when(functionalMenuService.regenerateAncestorTable()).thenReturn(expectedFieldValidator);
 198                 acutualFieldValidator = functionalMenuController.regenerateAncestorTable(mockedRequest, mockedResponse);
 199                 assertTrue(acutualFieldValidator.equals(expectedFieldValidator));
 200         }
 201
 202         @Test
 203         public void getFunctionalMenuStaticInfoExceptionTest(){
 204                 String fnMenuStaticactualResponse = null;
 205                 String fnMenuStaticexpectedResponse = null;
 206                 String orgUserIdStr = null;
 207
 208                 EPUser user = mockUser.mockEPUser();
 209                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 210                 Mockito.when(searchService.searchUserByUserId(orgUserIdStr)).thenReturn(user);
 211                 fnMenuStaticactualResponse = functionalMenuController.getFunctionalMenuStaticInfo(mockedRequest, mockedResponse);
 212
 213                 assertEquals(fnMenuStaticactualResponse, fnMenuStaticexpectedResponse);
 214
 215         }
 216
 217         @Test
 218         public void getFunctionalMenuStaticInfoTest(){
 219                 String fnMenuStaticactualResponse = null;
 220                 String fnMenuStaticexpectedResponse = "{\"firstName\":\"test\",\"lastName\":\"test\",\"last_login\":\"09/08/2017 03:48:13-0400\",\"userId\":\"guestT\",\"email\":\"test\"}";
 221                 String orgUserIdStr = null;
 222
 223                 EPUser user = mockUser.mockEPUser();
 224                 user.setEmail("test");
 225                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 226                 Mockito.when(searchService.searchUserByUserId(orgUserIdStr)).thenReturn(user);
 227                 fnMenuStaticactualResponse = functionalMenuController.getFunctionalMenuStaticInfo(mockedRequest, mockedResponse);
 228                 assertEquals(fnMenuStaticactualResponse.length(), fnMenuStaticexpectedResponse.length());
 229         }
 230
 231         @Test
 232         public void getMenuItemsForAuthUserNullTest(){
 233                 List<FunctionalMenuItem> actualmenuItems = null;
 234                 List<FunctionalMenuItem> expectedmenuItems = null;
 235
 236                 actualmenuItems = functionalMenuController.getMenuItemsForAuthUser(mockedRequest, mockedResponse);
 237                 assertEquals(actualmenuItems, expectedmenuItems);
 238         }
 239
 240         @Test
 241         public void getMenuItemsForAuthUserIsSuperAdminTest(){
 242                 List<FunctionalMenuItem> actualmenuItems = null;
 243                 List<FunctionalMenuItem> expectedmenuItems = new ArrayList<FunctionalMenuItem>();
 244                 EPUser user = mockUser.mockEPUser();
 245                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 246                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 247
 248                 actualmenuItems = functionalMenuController.getMenuItemsForAuthUser(mockedRequest, mockedResponse);
 249                 assertEquals(actualmenuItems, expectedmenuItems);
 250         }
 251
 252         @Test
 253         public void getMenuItemsForAuthUserTest(){
 254                 List<FunctionalMenuItem> actualmenuItems = null;
 255                 List<FunctionalMenuItem> expectedmenuItems = new ArrayList<FunctionalMenuItem>();
 256                 EPUser user = mockUser.mockEPUser();
 257                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 258                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 259
 260                 actualmenuItems = functionalMenuController.getMenuItemsForAuthUser(mockedRequest, mockedResponse);
 261                 assertEquals(actualmenuItems, expectedmenuItems);
 262         }
 263
 264         @Test
 265         public void getFunctionalMenuItemDetailsBadPermissionTest(){
 266                 Integer menuId = 1234;
 267                 FunctionalMenuItem actualmenuItem = null;
 268                 FunctionalMenuItem expectedmenuItem = null;
 269                 EPUser user = mockUser.mockEPUser();
 270                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 271
 272                 actualmenuItem = functionalMenuController.getFunctionalMenuItemDetails(mockedRequest, menuId, mockedResponse);
 273                 assertEquals(actualmenuItem, expectedmenuItem);
 274         }
 275
 276         @Test
 277         public void getFunctionalMenuItemDetailsTest(){
 278                 Integer menuId = 1234;
 279                 FunctionalMenuItem actualmenuItem = null;
 280                 FunctionalMenuItem expectedmenuItem = null;
 281                 EPUser user = mockUser.mockEPUser();
 282                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 283                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 284                 Mockito.when(functionalMenuService.getFunctionalMenuItemDetails(menuId)).thenReturn(actualmenuItem);
 285
 286                 actualmenuItem = functionalMenuController.getFunctionalMenuItemDetails(mockedRequest, menuId, mockedResponse);
 287                 assertEquals(actualmenuItem, expectedmenuItem);
 288         }
 289
 290         @Test
 291         public void getMenuItemsForEditingTest(){
 292                 List<FunctionalMenuItem> actualMenuItems = null;
 293                 List<FunctionalMenuItem> expectedMenuItems = null;
 294                 EPUser user = mockUser.mockEPUser();
 295                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 296                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 297                 Mockito.when(functionalMenuService.getFunctionalMenuItems(true)).thenReturn(actualMenuItems);
 298
 299                 actualMenuItems = functionalMenuController.getMenuItemsForEditing(mockedRequest, mockedResponse);
 300                 assertEquals(actualMenuItems, expectedMenuItems);
 301         }
 302
 303         @Test
 304         public void getMenuItemsForEditingBadPermissionsTest(){
 305                 List<FunctionalMenuItem> actualMenuItems = null;
 306                 List<FunctionalMenuItem> expectedMenuItems = null;
 307                 EPUser user = mockUser.mockEPUser();
 308                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 309                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 310                 Mockito.when(functionalMenuService.getFunctionalMenuItems(true)).thenReturn(actualMenuItems);
 311
 312                 actualMenuItems = functionalMenuController.getMenuItemsForEditing(mockedRequest, mockedResponse);
 313                 assertEquals(actualMenuItems, expectedMenuItems);
 314         }
 315
 316         @Test
 317         public void getMenuItemsForNotificationsTest(){
 318                 List<FunctionalMenuItem> actualMenuItems = null;
 319                 List<FunctionalMenuItem> expectedMenuItems = new ArrayList<FunctionalMenuItem>();
 320                 Mockito.when(functionalMenuService.getFunctionalMenuItemsForNotificationTree(false)).thenReturn(actualMenuItems);
 321
 322                 actualMenuItems = functionalMenuController.getMenuItemsForNotifications(mockedRequest, mockedResponse);
 323                 assertEquals(actualMenuItems, expectedMenuItems);
 324         }
 325
 326         @Test
 327         public void getMenuItemsForAppTest(){
 328                 Integer appId = 1234;
 329                 List<FunctionalMenuItem> actualMenuItems = null;
 330                 List<FunctionalMenuItem> expectedMenuItems = null;
 331                 Mockito.when(functionalMenuService.getFunctionalMenuItemsForApp(appId)).thenReturn(actualMenuItems);
 332
 333                 actualMenuItems = functionalMenuController.getMenuItemsForApp(mockedRequest, appId);
 334                 assertEquals(actualMenuItems, expectedMenuItems);
 335         }
 336
 337         @Test
 338         public void getMenuItemsForUserTest(){
 339                 String orgUserId ="test";
 340                 List<FunctionalMenuItem> actualMenuItems = null;
 341                 List<FunctionalMenuItem> expectedMenuItems = null;
 342                 Mockito.when(functionalMenuService.getFunctionalMenuItemsForUser(orgUserId)).thenReturn(actualMenuItems);
 343
 344                 actualMenuItems = functionalMenuController.getMenuItemsForUser(mockedRequest, orgUserId);
 345                 assertEquals(actualMenuItems, expectedMenuItems);
 346         }
 347
 348         @Test
 349         public void createFunctionalMenuItemTest(){
 350                 FieldsValidator actualFieldsValidator = new FieldsValidator();
 351                 FieldsValidator expectedFieldsValidator = new FieldsValidator();
 352                 List<FieldName> fields = new ArrayList<>();
 353                 expectedFieldsValidator.setHttpStatusCode((long) 200);
 354                 expectedFieldsValidator.setFields(fields);
 355                 expectedFieldsValidator.setErrorCode(null);
 356                 FunctionalMenuItemWithRoles menuItemJson = new FunctionalMenuItemWithRoles();
 357                 EPUser user = mockUser.mockEPUser();
 358                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 359                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 360                 Mockito.when(functionalMenuService.createFunctionalMenuItem(menuItemJson)).thenReturn(expectedFieldsValidator);
 361                 actualFieldsValidator = functionalMenuController.createFunctionalMenuItem(mockedRequest, menuItemJson, mockedResponse);
 362                 assertEquals(actualFieldsValidator, expectedFieldsValidator);
 363         }
 364
 365         @Test
 366         public void createFunctionalMenuItemBadPermisssionsTest(){
 367                 FieldsValidator actualFieldsValidator = null;
 368                 FieldsValidator expectedFieldsValidator = null;
 369                 FunctionalMenuItemWithRoles menuItemJson = new FunctionalMenuItemWithRoles();
 370                 EPUser user = mockUser.mockEPUser();
 371                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 372                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 373                 Mockito.when(functionalMenuService.createFunctionalMenuItem(menuItemJson)).thenReturn(expectedFieldsValidator);
 374                 actualFieldsValidator = functionalMenuController.createFunctionalMenuItem(mockedRequest, menuItemJson, mockedResponse);
 375                 assertEquals(actualFieldsValidator, expectedFieldsValidator);
 376         }
 377
 378         @Test
 379         public void getFavoritesForUserTest(){
 380                 List<FavoritesFunctionalMenuItemJson> actualFavoritesFunctionalMenuItemsJson = null;
 381                 List<FavoritesFunctionalMenuItemJson> expectedFunctionalMenuItemsJson = new ArrayList<FavoritesFunctionalMenuItemJson>();
 382                 EPUser user = mockUser.mockEPUser();
 383                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 384                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 385                 Mockito.when(functionalMenuService.getFavoriteItems(user.getId())).thenReturn(expectedFunctionalMenuItemsJson);
 386                 actualFavoritesFunctionalMenuItemsJson = functionalMenuController.getFavoritesForUser(mockedRequest, mockedResponse);
 387                 assertEquals(actualFavoritesFunctionalMenuItemsJson, expectedFunctionalMenuItemsJson);
 388         }
 389
 390         @Test
 391         public void deleteFavoriteItemTest(){
 392                 Long userId = (long)1;
 393                 Long menuId = (long)1;
 394                 FieldsValidator actualFieldsValidator = new FieldsValidator();
 395                 FieldsValidator expectedFieldsValidator = new FieldsValidator();
 396                 List<FieldName> fields = new ArrayList<>();
 397                 expectedFieldsValidator.setHttpStatusCode((long) 200);
 398                 expectedFieldsValidator.setFields(fields);
 399                 expectedFieldsValidator.setErrorCode(null);
 400                 EPUser user = mockUser.mockEPUser();
 401                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 402                 Mockito.when(functionalMenuService.removeFavoriteItem(user.getId(), menuId)).thenReturn(actualFieldsValidator);
 403                 actualFieldsValidator = functionalMenuController.deleteFavoriteItem(mockedRequest, menuId, mockedResponse);
 404                 assertEquals(actualFieldsValidator, expectedFieldsValidator);
 405         }
 406
 407         @Test
 408         public void addFavoriteItemTest(){
 409                 FavoritesFunctionalMenuItem menuItemJson = new FavoritesFunctionalMenuItem();
 410                 FieldsValidator actualFieldsValidator = new FieldsValidator();
 411                 FieldsValidator expectedFieldsValidator = new FieldsValidator();
 412                 List<FieldName> fields = new ArrayList<>();
 413                 expectedFieldsValidator.setHttpStatusCode((long) 200);
 414                 expectedFieldsValidator.setFields(fields);
 415                 expectedFieldsValidator.setErrorCode(null);
 416                 EPUser user = mockUser.mockEPUser();
 417                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 418                 Mockito.when(functionalMenuService.setFavoriteItem(menuItemJson)).thenReturn(actualFieldsValidator);
 419                 actualFieldsValidator = functionalMenuController.addFavoriteItem(mockedRequest, menuItemJson, mockedResponse);
 420                 assertEquals(actualFieldsValidator, expectedFieldsValidator);
 421         }
 422
 423         @Test
 424         public void getMenuItemsTest(){
 425                 List<FunctionalMenuItem> actualFunctionalMenuItems = new ArrayList<FunctionalMenuItem>();
 426                 List<FunctionalMenuItem> expectedFunctionalMenuItems = new ArrayList<FunctionalMenuItem>();
 427                 List<FunctionalMenuItem> menuItems = new ArrayList<FunctionalMenuItem>();
 428                 Mockito.when(functionalMenuService.getFunctionalMenuItems()).thenReturn(menuItems);
 429                 actualFunctionalMenuItems = functionalMenuController.getMenuItems(mockedRequest, mockedResponse);
 430                 assertEquals(actualFunctionalMenuItems, expectedFunctionalMenuItems);
 431         }
 432
 433         @Test
 434         public void deleteFunctionalMenuItemTest(){
 435                 Long menuId = (long)1;
 436                 FieldsValidator actualFieldsValidator = new FieldsValidator();
 437                 FieldsValidator expectedFieldsValidator = new FieldsValidator();
 438                 List<FieldName> fields = new ArrayList<>();
 439                 expectedFieldsValidator.setHttpStatusCode((long) 200);
 440                 expectedFieldsValidator.setFields(fields);
 441                 expectedFieldsValidator.setErrorCode(null);
 442                 EPUser user = mockUser.mockEPUser();
 443                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 444                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 445                 Mockito.when(functionalMenuService.deleteFunctionalMenuItem(menuId)).thenReturn(actualFieldsValidator);
 446                 actualFieldsValidator = functionalMenuController.deleteFunctionalMenuItem(mockedRequest, menuId, mockedResponse);
 447                 assertEquals(actualFieldsValidator, expectedFieldsValidator);
 448         }
 449
 450         @Test
 451         public void deleteFunctionalMenuItemBadPermissionsTest(){
 452                 Long menuId = (long)1;
 453                 FieldsValidator actualFieldsValidator = null;
 454                 FieldsValidator expectedFieldsValidator = null;
 455                 EPUser user = mockUser.mockEPUser();
 456                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 457                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 458                 Mockito.when(functionalMenuService.deleteFunctionalMenuItem(menuId)).thenReturn(actualFieldsValidator);
 459                 actualFieldsValidator = functionalMenuController.deleteFunctionalMenuItem(mockedRequest, menuId, mockedResponse);
 460                 assertEquals(actualFieldsValidator, expectedFieldsValidator);
 461         }
 462
 463         @Test
 464         public void editFunctionalMenuItemTest(){
 465                 FunctionalMenuItemWithRoles menuItemJson = new FunctionalMenuItemWithRoles();
 466                 FieldsValidator actualFieldsValidator = new FieldsValidator();
 467                 FieldsValidator expectedFieldsValidator = new FieldsValidator();
 468                 List<FieldName> fields = new ArrayList<>();
 469                 expectedFieldsValidator.setHttpStatusCode((long) 200);
 470                 expectedFieldsValidator.setFields(fields);
 471                 expectedFieldsValidator.setErrorCode(null);
 472                 EPUser user = mockUser.mockEPUser();
 473                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 474                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 475                 Mockito.when(functionalMenuService.editFunctionalMenuItem(menuItemJson)).thenReturn(actualFieldsValidator);
 476                 actualFieldsValidator = functionalMenuController.editFunctionalMenuItem(mockedRequest, menuItemJson, mockedResponse);
 477                 assertEquals(actualFieldsValidator, expectedFieldsValidator);
 478         }
 479
 480         @Test
 481         public void editFunctionalMenuItemBadPermissionsTest(){
 482                 FunctionalMenuItemWithRoles menuItemJson = new FunctionalMenuItemWithRoles();
 483                 FieldsValidator actualFieldsValidator = null;
 484                 FieldsValidator expectedFieldsValidator = null;
 485                 EPUser user = mockUser.mockEPUser();
 486                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 487                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 488                 Mockito.when(functionalMenuService.editFunctionalMenuItem(menuItemJson)).thenReturn(actualFieldsValidator);
 489                 actualFieldsValidator = functionalMenuController.editFunctionalMenuItem(mockedRequest, menuItemJson, mockedResponse);
 490                 assertEquals(actualFieldsValidator, expectedFieldsValidator);
 491         }
 492
 493         @Test
 494         public void getECOMPTitleTest(){
 495                 PortalRestResponse<String> actualportalRestResponse = null;
 496                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 497                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
 498                 expectedportalRestResponse.setMessage("success");
 499                 expectedportalRestResponse.setResponse("Portal");
 500                 PowerMockito.mockStatic(SystemProperties.class);
 501                 Mockito.when(SystemProperties.getProperty(SystemProperties.APP_DISPLAY_NAME)).thenReturn("Portal");
 502                 actualportalRestResponse = functionalMenuController.getECOMPTitle(mockedRequest, mockedResponse);
 503                 assertEquals(actualportalRestResponse, expectedportalRestResponse);
 504         }
 505
 506 }