ecomp-portal-BE-common/src/test/java/org/onap/portalapp/portal/controller/AppsControllerTest.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  * ECOMP is a trademark and service mark of AT&T Intellectual Property.
  37  */
  38 package org.onap.portalapp.portal.controller;
  39
  40 import static org.junit.Assert.*;
  41
  42 import java.io.IOException;
  43 import java.util.ArrayList;
  44 import java.util.HashSet;
  45 import java.util.List;
  46 import java.util.Set;
  47
  48 import javax.servlet.http.HttpServletRequest;
  49 import javax.servlet.http.HttpServletResponse;
  50
  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.Matchers;
  56 import org.mockito.Mock;
  57 import org.mockito.Mockito;
  58 import org.mockito.MockitoAnnotations;
  59 import org.onap.portalapp.portal.controller.AppsController;
  60 import org.onap.portalapp.portal.core.MockEPUser;
  61 import org.onap.portalapp.portal.domain.AdminUserApplications;
  62 import org.onap.portalapp.portal.domain.AppIdAndNameTransportModel;
  63 import org.onap.portalapp.portal.domain.AppsResponse;
  64 import org.onap.portalapp.portal.domain.EPApp;
  65 import org.onap.portalapp.portal.domain.EPUser;
  66 import org.onap.portalapp.portal.domain.EcompApp;
  67 import org.onap.portalapp.portal.domain.UserRole;
  68 import org.onap.portalapp.portal.domain.UserRoles;
  69 import org.onap.portalapp.portal.framework.MockitoTestSuite;
  70 import org.onap.portalapp.portal.service.AdminRolesService;
  71 import org.onap.portalapp.portal.service.AdminRolesServiceImpl;
  72 import org.onap.portalapp.portal.service.EPAppCommonServiceImpl;
  73 import org.onap.portalapp.portal.service.EPAppService;
  74 import org.onap.portalapp.portal.service.EPLeftMenuService;
  75 import org.onap.portalapp.portal.service.EPLeftMenuServiceImpl;
  76 import org.onap.portalapp.portal.transport.EPAppsManualPreference;
  77 import org.onap.portalapp.portal.transport.EPAppsSortPreference;
  78 import org.onap.portalapp.portal.transport.EPDeleteAppsManualSortPref;
  79 import org.onap.portalapp.portal.transport.EPWidgetsSortPreference;
  80 import org.onap.portalapp.portal.transport.FieldsValidator;
  81 import org.onap.portalapp.portal.transport.LocalRole;
  82 import org.onap.portalapp.portal.transport.OnboardingApp;
  83 import org.onap.portalapp.util.EPUserUtils;
  84 import org.onap.portalsdk.core.util.SystemProperties;
  85 import org.onap.portalsdk.core.web.support.AppUtils;
  86 import org.powermock.api.mockito.PowerMockito;
  87 import org.powermock.core.classloader.annotations.PrepareForTest;
  88 import org.powermock.modules.junit4.PowerMockRunner;
  89 import org.springframework.http.HttpEntity;
  90 import org.springframework.http.MediaType;
  91
  92 @RunWith(PowerMockRunner.class)
  93 @PrepareForTest({SystemProperties.class,AppUtils.class, EPUserUtils.class, MediaType.class})
  94 public class AppsControllerTest extends MockitoTestSuite{
  95
  96         @InjectMocks
  97         AppsController appsController = new AppsController();
  98
  99         @Mock
 100         AdminRolesService adminRolesService = new AdminRolesServiceImpl();
 101
 102         @Mock
 103         EPAppService appService = new EPAppCommonServiceImpl();
 104
 105         @Mock
 106         EPLeftMenuService leftMenuService = new EPLeftMenuServiceImpl();
 107
 108         @Before
 109         public void setup() {
 110                 MockitoAnnotations.initMocks(this);
 111         }
 112
 113         MockitoTestSuite mockitoTestSuite = new MockitoTestSuite();
 114
 115         HttpServletRequest mockedRequest = mockitoTestSuite.getMockedRequest();
 116         HttpServletResponse mockedResponse = mockitoTestSuite.getMockedResponse();
 117         NullPointerException nullPointerException = new NullPointerException();
 118
 119         @Mock
 120         EPUserUtils ePUserUtils = new EPUserUtils();
 121
 122         @Mock
 123         AppUtils appUtils = new AppUtils();
 124
 125         MockEPUser mockUser = new MockEPUser();
 126
 127         @Test
 128         public void getUserAppsTest() {
 129                 EPUser user = mockUser.mockEPUser();
 130                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 131                 List<EcompApp> expectedEcompApps = new ArrayList<EcompApp>();
 132
 133                 EcompApp ecompApp = new EcompApp();
 134                 ecompApp.setId((long) 1);
 135                 ecompApp.setName("Test_app");
 136                 ecompApp.setUrl("Test_URL");
 137                 ecompApp.setUebKey("Test_key");
 138                 ecompApp.setAlternateUrl("Test_alt_URL");
 139                 expectedEcompApps.add(ecompApp);
 140                 List<EcompApp> actualEcompApps = new ArrayList<EcompApp>();
 141                 Mockito.when(appService.transformAppsToEcompApps(appService.getUserApps(user))).thenReturn(expectedEcompApps);
 142                 actualEcompApps = appsController.getUserApps(mockedRequest, mockedResponse);
 143                 assertEquals(expectedEcompApps, actualEcompApps);
 144         }
 145
 146         @Test
 147         public void getUserAppsNoUserTest() {
 148                 EPUser user = null;
 149                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 150                 Mockito.when(appService.transformAppsToEcompApps(appService.getUserApps(user))).thenReturn(null);
 151                 assertNull(appsController.getUserApps(mockedRequest, mockedResponse));
 152
 153         }
 154
 155         @Test
 156         public void getUserAppsExceptionTest() {
 157                 EPUser user = mockUser.mockEPUser();
 158                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 159                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 160                 Mockito.when(appService.transformAppsToEcompApps(appService.getUserApps(user))).thenThrow(nullPointerException);
 161                 assertNull(appsController.getUserApps(mockedRequest, mockedResponse));
 162
 163         }
 164
 165         @Test
 166         public void getPersUserAppsIfUserIsAdminTest() throws IOException {
 167                 EPUser user = mockUser.mockEPUser();
 168                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 169                 List<EcompApp> expectedEcompApps = new ArrayList<EcompApp>();
 170
 171                 EcompApp ecompApp = new EcompApp();
 172                 ecompApp.setId((long) 1);
 173                 ecompApp.setName("Test_app");
 174                 ecompApp.setUrl("Test_URL");
 175                 ecompApp.setUebKey("Test_key");
 176                 ecompApp.setAlternateUrl("Test_alt_URL");
 177                 expectedEcompApps.add(ecompApp);
 178                 List<EcompApp> actualEcompApps = new ArrayList<EcompApp>();
 179
 180                 List<EPApp> expectedApps = new ArrayList<EPApp>();
 181
 182                 EPApp app = new EPApp();
 183
 184                 app.setName("Test");
 185                 app.setImageUrl("test");
 186                 app.setDescription("test");
 187                 app.setNotes("test");
 188                 app.setUrl("test");
 189                 app.setId((long) 1);
 190                 app.setAppRestEndpoint("test");
 191                 app.setAlternateUrl("test");
 192                 app.setName("test");
 193                 app.setMlAppName("test");
 194                 app.setMlAppAdminId("test");
 195                 app.setUsername("test");
 196                 app.setAppPassword("test");
 197                 app.setOpen(false);
 198                 app.setEnabled(false);
 199                 app.setUebKey("test");
 200                 app.setUebSecret("test");
 201                 app.setUebTopicName("test");
 202                 app.setAppType(1);
 203
 204                 expectedApps.add(app);
 205
 206                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 207                 Mockito.when(appService.getPersAdminApps(user)).thenReturn(expectedApps);
 208
 209                 Mockito.when(appService.transformAppsToEcompApps(expectedApps)).thenReturn(expectedEcompApps);
 210                 actualEcompApps = appsController.getPersUserApps(mockedRequest, mockedResponse);
 211                 assertEquals(expectedEcompApps, actualEcompApps);
 212         }
 213
 214         @Test
 215         public void getPersUserAppsIfUserNotAdminTest() throws IOException {
 216                 EPUser user = mockUser.mockEPUser();
 217                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 218                 List<EcompApp> expectedEcompApps = new ArrayList<EcompApp>();
 219
 220                 EcompApp ecompApp = new EcompApp();
 221                 ecompApp.setId((long) 1);
 222                 ecompApp.setName("Test_app");
 223                 ecompApp.setUrl("Test_URL");
 224                 ecompApp.setUebKey("Test_key");
 225                 ecompApp.setAlternateUrl("Test_alt_URL");
 226                 expectedEcompApps.add(ecompApp);
 227                 List<EcompApp> actualEcompApps = new ArrayList<EcompApp>();
 228
 229                 List<EPApp> expectedApps = new ArrayList<EPApp>();
 230
 231                 EPApp app = new EPApp();
 232
 233                 app.setName("Test");
 234                 app.setImageUrl("test");
 235                 app.setDescription("test");
 236                 app.setNotes("test");
 237                 app.setUrl("test");
 238                 app.setId((long) 1);
 239                 app.setAppRestEndpoint("test");
 240                 app.setAlternateUrl("test");
 241                 app.setName("test");
 242                 app.setMlAppName("test");
 243                 app.setMlAppAdminId("test");
 244                 app.setUsername("test");
 245                 app.setAppPassword("test");
 246                 app.setOpen(false);
 247                 app.setEnabled(false);
 248                 app.setUebKey("test");
 249                 app.setUebSecret("test");
 250                 app.setUebTopicName("test");
 251                 app.setAppType(1);
 252
 253                 expectedApps.add(app);
 254
 255                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 256                 Mockito.when(appService.getPersUserApps(user)).thenReturn(expectedApps);
 257                 Mockito.when(appService.transformAppsToEcompApps(expectedApps)).thenReturn(expectedEcompApps);
 258                 actualEcompApps = appsController.getPersUserApps(mockedRequest, mockedResponse);
 259                 assertEquals(expectedEcompApps, actualEcompApps);
 260         }
 261
 262         @Test
 263         public void getPersUserAppsIfUserNullTest() throws IOException {
 264                 EPUser user = null;
 265                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 266                 assertNull(appsController.getPersUserApps(mockedRequest, mockedResponse));
 267         }
 268
 269         @Test
 270         public void getPersUserAppsExceptionTest() throws IOException {
 271                 EPUser user = mockUser.mockEPUser();
 272                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 273                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 274                 Mockito.when(appService.getPersAdminApps(user)).thenThrow(nullPointerException);
 275                 assertNull(appsController.getPersUserApps(mockedRequest, mockedResponse));
 276         }
 277
 278         @Test
 279         public void getAdminAppsIfNotAdminTest() {
 280                 EPUser user = mockUser.mockEPUser();
 281                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 282                 Mockito.when(adminRolesService.isAccountAdmin(user)).thenReturn(false);
 283                 assertNull(appsController.getAdminApps(mockedRequest, mockedResponse));
 284         }
 285
 286         @Test
 287         public void getAdminAppsTest() {
 288                 EPUser user = mockUser.mockEPUser();
 289                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 290                 List<AppIdAndNameTransportModel> expectedAdminApps = new ArrayList<AppIdAndNameTransportModel>();
 291                 AppIdAndNameTransportModel appIdAndNameTransportModel = new AppIdAndNameTransportModel();
 292                 appIdAndNameTransportModel.setId((long) 1);
 293                 appIdAndNameTransportModel.setName("Test_app");
 294                 expectedAdminApps.add(appIdAndNameTransportModel);
 295                 List<AppIdAndNameTransportModel> actualAdminApps = new ArrayList<AppIdAndNameTransportModel>();
 296                 Mockito.when(adminRolesService.isAccountAdmin(user)).thenReturn(true);
 297                 Mockito.when(appService.getAdminApps(user)).thenReturn(expectedAdminApps);
 298                 actualAdminApps = appsController.getAdminApps(mockedRequest, mockedResponse);
 299                 assertEquals(actualAdminApps, expectedAdminApps);
 300
 301         }
 302
 303         @Test
 304         public void getAdminAppsExceptionTest() {
 305                 EPUser user = mockUser.mockEPUser();
 306                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 307                 Mockito.when(adminRolesService.isAccountAdmin(user)).thenReturn(true);
 308                 Mockito.when(appService.getAdminApps(user)).thenThrow(nullPointerException);
 309                 assertNull(appsController.getAdminApps(mockedRequest, mockedResponse));
 310         }
 311
 312         @Test
 313         public void getAppsForSuperAdminAndAccountAdminifOnlyAccountAdminTest() {
 314                 EPUser user = mockUser.mockEPUser();
 315                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 316                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 317                 Mockito.when(adminRolesService.isAccountAdmin(user)).thenReturn(false);
 318                 assertNull(appsController.getAppsForSuperAdminAndAccountAdmin(mockedRequest, mockedResponse));
 319         }
 320
 321         @Test
 322         public void getAppsForSuperAdminAndAccountAdminTest() {
 323                 EPUser user = mockUser.mockEPUser();
 324                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 325                 List<AppIdAndNameTransportModel> expectedAdminApps = new ArrayList<AppIdAndNameTransportModel>();
 326                 AppIdAndNameTransportModel appIdAndNameTransportModel = new AppIdAndNameTransportModel();
 327                 appIdAndNameTransportModel.setId((long) 1);
 328                 appIdAndNameTransportModel.setName("Test_app");
 329                 expectedAdminApps.add(appIdAndNameTransportModel);
 330                 List<AppIdAndNameTransportModel> actualAdminApps = new ArrayList<AppIdAndNameTransportModel>();
 331                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 332                 Mockito.when(adminRolesService.isAccountAdmin(user)).thenReturn(true);
 333                 Mockito.when(appService.getAppsForSuperAdminAndAccountAdmin(user)).thenReturn(expectedAdminApps);
 334                 actualAdminApps = appsController.getAppsForSuperAdminAndAccountAdmin(mockedRequest, mockedResponse);
 335                 assertEquals(actualAdminApps, expectedAdminApps);
 336
 337         }
 338
 339         @Test
 340         public void getAppsForSuperAdminExceptionTest() {
 341                 EPUser user = mockUser.mockEPUser();
 342                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 343                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 344                 Mockito.when(adminRolesService.isAccountAdmin(user)).thenReturn(false);
 345                 Mockito.when(appService.getAppsForSuperAdminAndAccountAdmin(user)).thenThrow(nullPointerException);
 346                 assertNull(appsController.getAppsForSuperAdminAndAccountAdmin(mockedRequest, mockedResponse));
 347         }
 348
 349         @Test
 350         public void putUserAppsSortingManualTest() throws IOException {
 351                 EPUser user = mockUser.mockEPUser();
 352                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 353                 List<EPAppsManualPreference> ePAppsManualPreference = new ArrayList<EPAppsManualPreference>();
 354                 FieldsValidator expectedFieldValidator = new FieldsValidator();
 355                 expectedFieldValidator.setHttpStatusCode((long) 200);
 356                 expectedFieldValidator.setFields(null);
 357                 expectedFieldValidator.setErrorCode(null);
 358                 FieldsValidator actualFieldValidator = new FieldsValidator();
 359                 Mockito.when(appService.saveAppsSortManual(ePAppsManualPreference, user)).thenReturn(expectedFieldValidator);
 360                 actualFieldValidator = appsController.putUserAppsSortingManual(mockedRequest, ePAppsManualPreference,
 361                                 mockedResponse);
 362                 assertEquals(actualFieldValidator, expectedFieldValidator);
 363         }
 364
 365         @Test
 366         public void putUserAppsSortingManualExceptionTest() throws IOException {
 367                 EPUser user = mockUser.mockEPUser();
 368                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 369                 List<EPAppsManualPreference> ePAppsManualPreference = new ArrayList<EPAppsManualPreference>();
 370                 Mockito.when(appService.saveAppsSortManual(ePAppsManualPreference, user)).thenThrow(nullPointerException);
 371                 assertNull(appsController.putUserAppsSortingManual(mockedRequest, ePAppsManualPreference, mockedResponse));
 372         }
 373
 374         @Test
 375         public void putUserWidgetsSortManualTest() throws IOException {
 376                 EPUser user = mockUser.mockEPUser();
 377                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 378                 List<EPWidgetsSortPreference> ePWidgetsSortPreference = new ArrayList<EPWidgetsSortPreference>();
 379                 FieldsValidator expectedFieldValidator = new FieldsValidator();
 380                 expectedFieldValidator.setHttpStatusCode((long) 200);
 381                 expectedFieldValidator.setFields(null);
 382                 expectedFieldValidator.setErrorCode(null);
 383                 FieldsValidator actualFieldValidator = new FieldsValidator();
 384                 Mockito.when(appService.saveWidgetsSortManual(ePWidgetsSortPreference, user))
 385                                 .thenReturn(expectedFieldValidator);
 386                 actualFieldValidator = appsController.putUserWidgetsSortManual(mockedRequest, ePWidgetsSortPreference,
 387                                 mockedResponse);
 388                 assertEquals(actualFieldValidator, expectedFieldValidator);
 389         }
 390
 391         @Test
 392         public void putUserWidgetsSortManualExceptionTest() throws IOException {
 393                 EPUser user = mockUser.mockEPUser();
 394                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 395                 List<EPAppsManualPreference> ePAppsManualPreference = new ArrayList<EPAppsManualPreference>();
 396                 Mockito.when(appService.saveAppsSortManual(ePAppsManualPreference, user)).thenThrow(nullPointerException);
 397                 assertNull(appsController.putUserAppsSortingManual(mockedRequest, ePAppsManualPreference, mockedResponse));
 398         }
 399
 400         @Test
 401         public void putUserWidgetsSortPrefTest() throws IOException {
 402                 EPUser user = mockUser.mockEPUser();
 403                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 404                 List<EPWidgetsSortPreference> ePWidgetsSortPreference = new ArrayList<EPWidgetsSortPreference>();
 405                 FieldsValidator expectedFieldValidator = new FieldsValidator();
 406                 expectedFieldValidator.setHttpStatusCode((long) 200);
 407                 expectedFieldValidator.setFields(null);
 408                 expectedFieldValidator.setErrorCode(null);
 409                 FieldsValidator actualFieldValidator = new FieldsValidator();
 410                 Mockito.when(appService.deleteUserWidgetSortPref(ePWidgetsSortPreference, user))
 411                                 .thenReturn(expectedFieldValidator);
 412                 actualFieldValidator = appsController.putUserWidgetsSortPref(mockedRequest, ePWidgetsSortPreference,
 413                                 mockedResponse);
 414                 assertEquals(actualFieldValidator, expectedFieldValidator);
 415         }
 416
 417         @Test
 418         public void putUserWidgetsSortPrefExceptionTest() throws IOException {
 419                 EPUser user = mockUser.mockEPUser();
 420                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 421                 List<EPWidgetsSortPreference> ePWidgetsSortPreference = new ArrayList<EPWidgetsSortPreference>();
 422                 Mockito.when(appService.deleteUserWidgetSortPref(ePWidgetsSortPreference, user))
 423                                 .thenThrow(nullPointerException);
 424                 assertNull(appsController.putUserWidgetsSortPref(mockedRequest, ePWidgetsSortPreference, mockedResponse));
 425         }
 426
 427         @Test
 428         public void deleteUserAppSortManualTest() throws IOException {
 429                 EPUser user = mockUser.mockEPUser();
 430                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 431                 EPDeleteAppsManualSortPref epDeleteAppsManualSortPref = new EPDeleteAppsManualSortPref();
 432
 433                 FieldsValidator expectedFieldValidator = new FieldsValidator();
 434                 expectedFieldValidator.setHttpStatusCode((long) 200);
 435                 expectedFieldValidator.setFields(null);
 436                 expectedFieldValidator.setErrorCode(null);
 437                 FieldsValidator actualFieldValidator = new FieldsValidator();
 438                 Mockito.when(appService.deleteUserAppSortManual(epDeleteAppsManualSortPref, user))
 439                                 .thenReturn(expectedFieldValidator);
 440                 actualFieldValidator = appsController.deleteUserAppSortManual(mockedRequest, epDeleteAppsManualSortPref,
 441                                 mockedResponse);
 442                 assertEquals(actualFieldValidator, expectedFieldValidator);
 443         }
 444
 445         @Test
 446         public void deleteUserAppSortManualExceptionTest() throws IOException {
 447                 EPUser user = mockUser.mockEPUser();
 448                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 449                 EPDeleteAppsManualSortPref epDeleteAppsManualSortPref = new EPDeleteAppsManualSortPref();
 450                 Mockito.when(appService.deleteUserAppSortManual(epDeleteAppsManualSortPref, user))
 451                                 .thenThrow(nullPointerException);
 452                 assertNull(appsController.deleteUserAppSortManual(mockedRequest, epDeleteAppsManualSortPref, mockedResponse));
 453         }
 454
 455         @Test
 456         public void putUserAppsSortingPreferenceTest() throws IOException {
 457                 EPUser user = mockUser.mockEPUser();
 458                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 459                 EPAppsSortPreference userAppsValue = new EPAppsSortPreference();
 460
 461                 FieldsValidator expectedFieldValidator = new FieldsValidator();
 462                 expectedFieldValidator.setHttpStatusCode((long) 200);
 463                 expectedFieldValidator.setFields(null);
 464                 expectedFieldValidator.setErrorCode(null);
 465                 FieldsValidator actualFieldValidator = new FieldsValidator();
 466                 Mockito.when(appService.saveAppsSortPreference(userAppsValue, user)).thenReturn(expectedFieldValidator);
 467                 actualFieldValidator = appsController.putUserAppsSortingPreference(mockedRequest, userAppsValue,
 468                                 mockedResponse);
 469                 assertEquals(actualFieldValidator, expectedFieldValidator);
 470         }
 471
 472         @Test
 473         public void putUserAppsSortingPreferenceExceptionTest() throws IOException {
 474                 EPUser user = mockUser.mockEPUser();
 475                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 476                 EPAppsSortPreference userAppsValue = new EPAppsSortPreference();
 477                 Mockito.when(appService.saveAppsSortPreference(userAppsValue, user)).thenThrow(nullPointerException);
 478                 assertNull(appsController.putUserAppsSortingPreference(mockedRequest, userAppsValue, mockedResponse));
 479         }
 480
 481         @Test
 482         public void getUserAppsSortTypePreferenceTest() throws IOException {
 483                 EPUser user = mockUser.mockEPUser();
 484                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 485                 String expectedUserSortPreference = "TEST_DECE";
 486                 String actualUserSortPreference = new String();
 487                 Mockito.when(appService.getUserAppsSortTypePreference(user)).thenReturn(expectedUserSortPreference);
 488                 actualUserSortPreference = appsController.getUserAppsSortTypePreference(mockedRequest, mockedResponse);
 489                 assertEquals(actualUserSortPreference, expectedUserSortPreference);
 490         }
 491
 492         @Test
 493         public void getUserAppsSortTypePreferenceExceptionTest() throws IOException {
 494                 EPUser user = mockUser.mockEPUser();
 495                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 496                 Mockito.when(appService.getUserAppsSortTypePreference(user)).thenThrow(nullPointerException);
 497                 assertNull(appsController.getUserAppsSortTypePreference(mockedRequest, mockedResponse));
 498         }
 499
 500         @Test
 501         public void getUserAppsSortTypePreferenceIfUserNullTest() throws IOException {
 502                 EPUser user = null;
 503                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 504                 Mockito.when(appService.getUserAppsSortTypePreference(user)).thenThrow(nullPointerException);
 505                 assertNull(appsController.getUserAppsSortTypePreference(mockedRequest, mockedResponse));
 506         }
 507
 508         @Test
 509         public void getAppsAdministratorsTest() throws IOException {
 510                 EPUser user = mockUser.mockEPUser();
 511                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 512                 List<AdminUserApplications> expecteAdminUserApplications = new ArrayList<AdminUserApplications>();
 513                 List<AdminUserApplications> actualAdminUserApplications = new ArrayList<AdminUserApplications>();
 514                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 515                 Mockito.when(appService.getAppsAdmins()).thenReturn(expecteAdminUserApplications);
 516                 actualAdminUserApplications = appsController.getAppsAdministrators(mockedRequest, mockedResponse);
 517                 assertEquals(expecteAdminUserApplications, actualAdminUserApplications);
 518         }
 519
 520         @Test
 521         public void getAppsAdministratorsIfUserNotSuperAdminTest() throws IOException {
 522                 EPUser user = mockUser.mockEPUser();
 523                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 524                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 525                 assertNull(appsController.getUserAppsSortTypePreference(mockedRequest, mockedResponse));
 526         }
 527
 528         @Test
 529         public void getAppsAdministratorsExceptionTest() throws IOException {
 530                 EPUser user = mockUser.mockEPUser();
 531                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 532                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 533                 Mockito.when(appService.getAppsAdmins()).thenThrow(nullPointerException);
 534                 assertNull(appsController.getUserAppsSortTypePreference(mockedRequest, mockedResponse));
 535         }
 536
 537         @Test
 538         public void getAppsTest() throws IOException {
 539                 EPUser user = mockUser.mockEPUser();
 540                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 541                 List<AppsResponse> expectedApps = new ArrayList<AppsResponse>();
 542                 AppsResponse apps = new AppsResponse((long) 1, "test", true, true);
 543                 expectedApps.add(apps);
 544
 545                 List<AppsResponse> atualApps = new ArrayList<AppsResponse>();
 546
 547                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 548                 Mockito.when(appService.getAllApps(false)).thenReturn(expectedApps);
 549                 atualApps = appsController.getApps(mockedRequest, mockedResponse);
 550                 assertEquals(expectedApps, atualApps);
 551         }
 552
 553         @Test
 554         public void getAppsExceptionTest() throws IOException {
 555                 EPUser user = mockUser.mockEPUser();
 556                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 557                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 558                 assertNull(appsController.getApps(mockedRequest, mockedResponse));
 559         }
 560
 561         @Test
 562         public void getAppsIfUserNotSuperAdminTest() throws IOException {
 563                 EPUser user = mockUser.mockEPUser();
 564                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 565                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 566                 Mockito.when(appService.getAllApps(false)).thenThrow(nullPointerException);
 567                 assertNull(appsController.getApps(mockedRequest, mockedResponse));
 568         }
 569
 570         @Test
 571         public void getAllAppsTest() throws IOException {
 572                 EPUser user = mockUser.mockEPUser();
 573                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 574                 List<AppsResponse> expectedApps = new ArrayList<AppsResponse>();
 575                 AppsResponse apps = new AppsResponse((long) 1, "test", true, true);
 576                 expectedApps.add(apps);
 577                 List<AppsResponse> atualApps = new ArrayList<AppsResponse>();
 578                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 579                 Mockito.when(appService.getAllApps(true)).thenReturn(expectedApps);
 580                 atualApps = appsController.getAllApps(mockedRequest, mockedResponse);
 581                 assertEquals(expectedApps, atualApps);
 582         }
 583
 584         @Test
 585         public void getAllAppsExceptionTest() throws IOException {
 586                 EPUser user = mockUser.mockEPUser();
 587                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 588                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 589                 assertNull(appsController.getAllApps(mockedRequest, mockedResponse));
 590         }
 591
 592         @Test
 593         public void getAllAppsIfUserNotSuperAdminTest() throws IOException {
 594                 EPUser user = mockUser.mockEPUser();
 595                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 596                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 597                 Mockito.when(appService.getAllApps(true)).thenThrow(nullPointerException);
 598                 assertNull(appsController.getAllApps(mockedRequest, mockedResponse));
 599         }
 600
 601         @Test
 602         public void getAppsFullListTest() {
 603                 EPUser user = mockUser.mockEPUser();
 604                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 605                 List<EcompApp> expectedEcompApps = new ArrayList<EcompApp>();
 606
 607                 EcompApp ecompApp = new EcompApp();
 608                 ecompApp.setId((long) 1);
 609                 ecompApp.setName("Test_app");
 610                 ecompApp.setUrl("Test_URL");
 611                 ecompApp.setUebKey("Test_key");
 612                 ecompApp.setAlternateUrl("Test_alt_URL");
 613                 expectedEcompApps.add(ecompApp);
 614                 List<EcompApp> actualEcompApps = new ArrayList<EcompApp>();
 615                 Mockito.when(appService.getEcompAppAppsFullList()).thenReturn(expectedEcompApps);
 616                 actualEcompApps = appsController.getAppsFullList(mockedRequest, mockedResponse);
 617                 assertEquals(expectedEcompApps, actualEcompApps);
 618         }
 619
 620 //      @Test
 621 //      public void getAppsFullListNoUserTest() {
 622 //              EPUser user = null;
 623 //              Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 624 //              Mockito.when(appService.getEcompAppAppsFullList()).thenReturn(null);
 625 //              assertNull(appsController.getAppsFullList(mockedRequest, mockedResponse));
 626 //
 627 //      }
 628
 629         @Test
 630         public void getUserProfileTest() {
 631                 EPUser user = mockUser.mockEPUser();
 632                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 633
 634                 UserRole userRole = new UserRole();
 635                 userRole.setUser_Id((long) 1);
 636                 userRole.setOrgUserId("guest");
 637                 userRole.setFirstName("Test_User_FirstName");
 638                 userRole.setLastName("Test_User_LastName");
 639                 userRole.setRoleId((long) 1);
 640                 userRole.setRoleName("test");
 641
 642                 UserRoles unexpectedserAndRoles = new UserRoles(userRole);
 643                 unexpectedserAndRoles.setFirstName("Test_User_FirstName");
 644                 unexpectedserAndRoles.setLastName("Test_User_LastName");
 645                 unexpectedserAndRoles.setGuestSession(false);
 646                 unexpectedserAndRoles.setOrgUserId("guest");
 647                 List<String> roles = new ArrayList<String>();
 648                 roles.add("Test");
 649                 unexpectedserAndRoles.setRoles(roles);
 650                 Mockito.when(appService.getUserProfileNormalized(user)).thenReturn(unexpectedserAndRoles);
 651                 UserRoles actualUserAndRoles = appsController.getUserProfile(mockedRequest, mockedResponse);
 652                 assertEquals(unexpectedserAndRoles, actualUserAndRoles);
 653         }
 654
 655         @Test
 656         public void getUserProfileIfUserNullTest() throws IOException {
 657                 EPUser user = null;
 658                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 659                 Mockito.when(appService.getUserProfileNormalized(user)).thenReturn(null);
 660                 assertNull(appsController.getUserAppsSortTypePreference(mockedRequest, mockedResponse));
 661         }
 662
 663         @Test
 664         public void getUserProfileExcpetionTest() throws IOException {
 665                 EPUser user = mockUser.mockEPUser();
 666                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 667                 Mockito.when(appService.getUserProfileNormalized(user)).thenThrow(nullPointerException);
 668                 assertNull(appsController.getUserAppsSortTypePreference(mockedRequest, mockedResponse));
 669         }
 670
 671         @Test
 672         public void getAppRolesTest() {
 673                 List<LocalRole> expectedRoleList = new ArrayList<LocalRole>();
 674                 LocalRole localRole = new LocalRole();
 675                 localRole.setRoleId(1);
 676                 localRole.setRolename("test");
 677                 expectedRoleList.add(localRole);
 678                 long appId = 1;
 679                 Mockito.when(appService.getAppRoles(appId)).thenReturn(expectedRoleList);
 680                 EPUser user = mockUser.mockEPUser();
 681                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 682                 Mockito.when(adminRolesService.isAccountAdminOfApplication(Matchers.anyObject(), Matchers.anyObject())).thenReturn(true);
 683                 List<LocalRole> actualRoleList = appsController.getAppRoles(mockedRequest, appId, mockedResponse);
 684                 assertEquals(actualRoleList, expectedRoleList);
 685         }
 686
 687         @Test
 688         public void getAppRolesExceptionTest() {
 689                 long appId = 1;
 690                 Mockito.when(appService.getAppRoles(appId)).thenThrow(nullPointerException);
 691                 assertNull(appsController.getAppRoles(mockedRequest, appId, mockedResponse));
 692         }
 693
 694         @Test
 695         public void getOnboardingAppsTest() {
 696                 EPUser user = mockUser.mockEPUser();
 697                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 698                 List<OnboardingApp> expectedOnboardingApps = new ArrayList<OnboardingApp>();
 699                 OnboardingApp onboardingApp = new OnboardingApp();
 700                 onboardingApp.setUebKey("test");
 701                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 702                 Mockito.when(appService.getOnboardingApps()).thenReturn(expectedOnboardingApps);
 703                 List<OnboardingApp> actualOnboardingApps = appsController.getOnboardingApps(mockedRequest, mockedResponse);
 704                 assertEquals(expectedOnboardingApps, actualOnboardingApps);
 705         }
 706
 707         @Test
 708         public void getOnboardingAppsifSuperAdiminTest() {
 709                 EPUser user = mockUser.mockEPUser();
 710                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 711                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 712                 assertNull(appsController.getOnboardingApps(mockedRequest, mockedResponse));
 713         }
 714
 715         @Test
 716         public void getOnboardingAppsExceptionTest() {
 717                 EPUser user = mockUser.mockEPUser();
 718                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 719                 Mockito.when(!adminRolesService.isSuperAdmin(user)).thenReturn(true);
 720                 Mockito.when(appService.getOnboardingApps()).thenThrow(nullPointerException);
 721                 assertNull(appsController.getOnboardingApps(mockedRequest, mockedResponse));
 722         }
 723
 724         @Test
 725         public void putOnboardingAppTest() {
 726                 EPUser user = mockUser.mockEPUser();
 727                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 728                 OnboardingApp OnboardingApp = new OnboardingApp();
 729                 FieldsValidator expectedFieldValidator = new FieldsValidator();
 730                 expectedFieldValidator.setHttpStatusCode((long) 200);
 731                 expectedFieldValidator.setFields(null);
 732                 expectedFieldValidator.setErrorCode(null);
 733                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 734                 Mockito.when(appService.modifyOnboardingApp(OnboardingApp, user)).thenReturn(expectedFieldValidator);
 735                 FieldsValidator actualFieldValidator = appsController.putOnboardingApp(mockedRequest, OnboardingApp,
 736                                 mockedResponse);
 737                 assertEquals(expectedFieldValidator, actualFieldValidator);
 738         }
 739
 740         @Test
 741         public void putOnboardingAppIfSuperAdminTest() {
 742                 EPUser user = mockUser.mockEPUser();
 743                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 744                 FieldsValidator expectedFieldValidator = null;
 745                 OnboardingApp OnboardingApp = new OnboardingApp();
 746                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 747                 Mockito.when(appService.modifyOnboardingApp(OnboardingApp, user)).thenReturn(expectedFieldValidator);
 748                 assertNull(appsController.putOnboardingApp(mockedRequest, OnboardingApp, mockedResponse));
 749         }
 750
 751         @Test
 752         public void putOnboardingAppExceptionTest() {
 753                 EPUser user = mockUser.mockEPUser();
 754                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 755                 OnboardingApp OnboardingApp = new OnboardingApp();
 756                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 757                 Mockito.when(appService.modifyOnboardingApp(OnboardingApp, user)).thenThrow(nullPointerException);
 758                 assertNull(appsController.putOnboardingApp(mockedRequest, OnboardingApp, mockedResponse));
 759         }
 760
 761         @Test
 762         public void postOnboardingAppTest() {
 763                 EPUser user = mockUser.mockEPUser();
 764                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 765                 OnboardingApp OnboardingApp = new OnboardingApp();
 766                 FieldsValidator expectedFieldValidator = new FieldsValidator();
 767                 expectedFieldValidator.setHttpStatusCode((long) 200);
 768                 expectedFieldValidator.setFields(null);
 769                 expectedFieldValidator.setErrorCode(null);
 770                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 771                 Mockito.when(appService.addOnboardingApp(OnboardingApp, user)).thenReturn(expectedFieldValidator);
 772                 FieldsValidator actualFieldValidator = appsController.postOnboardingApp(mockedRequest, OnboardingApp,
 773                                 mockedResponse);
 774                 assertEquals(expectedFieldValidator, actualFieldValidator);
 775         }
 776
 777         @Test
 778         public void postOnboardingAppIfSuperAdminTest() {
 779                 EPUser user = mockUser.mockEPUser();
 780                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 781                 FieldsValidator expectedFieldValidator = null;
 782                 OnboardingApp OnboardingApp = new OnboardingApp();
 783                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 784                 Mockito.when(appService.addOnboardingApp(OnboardingApp, user)).thenReturn(expectedFieldValidator);
 785                 assertNull(appsController.postOnboardingApp(mockedRequest, OnboardingApp, mockedResponse));
 786         }
 787
 788         @Test
 789         public void postOnboardingAppExceptionTest() {
 790                 EPUser user = mockUser.mockEPUser();
 791                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 792                 OnboardingApp OnboardingApp = new OnboardingApp();
 793                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 794                 Mockito.when(appService.addOnboardingApp(OnboardingApp, user)).thenThrow(nullPointerException);
 795                 assertNull(appsController.postOnboardingApp(mockedRequest, OnboardingApp, mockedResponse));
 796         }
 797
 798         @Test
 799         public void deleteOnboardingAppTest() {
 800                 EPUser user = mockUser.mockEPUser();
 801                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 802                 FieldsValidator expectedFieldValidator = new FieldsValidator();
 803                 expectedFieldValidator.setHttpStatusCode((long) 200);
 804                 expectedFieldValidator.setFields(null);
 805                 expectedFieldValidator.setErrorCode(null);
 806                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 807                 long appId = 1;
 808                 Mockito.when(appService.deleteOnboardingApp(user,appId )).thenReturn(expectedFieldValidator);
 809                 FieldsValidator actualFieldValidator = appsController.deleteOnboardingApp(mockedRequest,appId,
 810                                 mockedResponse);
 811                 assertEquals(expectedFieldValidator, actualFieldValidator);
 812         }
 813
 814         @Test
 815         public void deleteOnboardingAppIfSuperAdminTest() {
 816                 EPUser user = mockUser.mockEPUser();
 817                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 818                 FieldsValidator expectedFieldValidator = null;
 819                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 820                 long appId = 1;
 821         Mockito.when(appService.deleteOnboardingApp(user,appId)).thenReturn(expectedFieldValidator);
 822                 assertNull(appsController.deleteOnboardingApp(mockedRequest,appId,mockedResponse));
 823         }
 824
 825         @Test
 826         public void deleteOnboardingAppExceptionTest() {
 827                 EPUser user = mockUser.mockEPUser();
 828                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 829                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 830                 long appId = 1;
 831       Mockito.when(appService.deleteOnboardingApp(user,appId)).thenThrow(nullPointerException);
 832                 assertNull(appsController.deleteOnboardingApp(mockedRequest,appId,mockedResponse));
 833         }
 834
 835         @Test
 836         public void getLeftMenuItemsTest()
 837         {
 838                 EPUser user = mockUser.mockEPUser();
 839                 String menuList = "Test";
 840                 PowerMockito.mockStatic(EPUserUtils.class);
 841                 PowerMockito.mockStatic(SystemProperties.class);
 842                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 843                 Set menuSet = new HashSet<>();
 844                 menuSet.add(1);
 845                 Mockito.when(AppUtils.getSession(mockedRequest)
 846                                 .getAttribute(SystemProperties.getProperty(SystemProperties.APPLICATION_MENU_ATTRIBUTE_NAME))).thenReturn(menuSet);
 847                 Mockito.when(AppUtils.getSession(mockedRequest)
 848                                 .getAttribute(SystemProperties.getProperty(SystemProperties.ROLE_FUNCTIONS_ATTRIBUTE_NAME))).thenReturn(menuSet);
 849                 Mockito.when(leftMenuService.getLeftMenuItems(user, menuSet, menuSet)).thenReturn(menuList);
 850                 String response = appsController.getLeftMenuItems(mockedRequest, mockedResponse);
 851                 assertTrue(response.equals("Test"));
 852         }
 853
 854         @Test
 855         public void getLeftMenuItemsExceptionTest()
 856         {
 857                 EPUser user = mockUser.mockEPUser();
 858                 String menuList = "Test";
 859                 PowerMockito.mockStatic(EPUserUtils.class);
 860                 PowerMockito.mockStatic(SystemProperties.class);
 861                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 862                 Set menuSet = new HashSet<>();
 863                 menuSet.add(1);
 864                 Mockito.when(AppUtils.getSession(mockedRequest)
 865                                 .getAttribute(SystemProperties.getProperty(SystemProperties.APPLICATION_MENU_ATTRIBUTE_NAME))).thenReturn(menuSet);
 866                 Mockito.when(AppUtils.getSession(mockedRequest)
 867                                 .getAttribute(SystemProperties.getProperty(SystemProperties.ROLE_FUNCTIONS_ATTRIBUTE_NAME))).thenReturn(menuSet);
 868                 Mockito.when(leftMenuService.getLeftMenuItems(user, menuSet, menuSet)).thenThrow(nullPointerException);
 869                 assertNull(appsController.getLeftMenuItems(mockedRequest, mockedResponse));
 870         }
 871
 872         @Test
 873         public void getAppThumbnailExceptionTest()
 874         {
 875                 EPApp app = null;
 876                 assertNull(appsController.getAppThumbnail(mockedRequest, (long) 1, mockedResponse));
 877         }
 878
 879         @Test
 880         public void getAppThumbnailTest()
 881         {
 882                 EPApp app = new EPApp();
 883                 app.setName("Test");
 884                 app.setImageUrl("test");
 885                 app.setDescription("test");
 886                 app.setNotes("test");
 887                 app.setUrl("test");
 888                 app.setId((long) 1);
 889                 app.setAppType(1);
 890                 app.setImageUrl("www.ecomp.com");
 891                 app.setThumbnail(new byte[] {1, 6, 3});
 892                 Mockito.when(appService.getApp((long) 1)).thenReturn(app);
 893                 HttpEntity<byte[]> response = appsController.getAppThumbnail(mockedRequest, (long) 1, mockedResponse);
 894                 assertEquals(response.getHeaders().getContentLength(), 3);
 895         }
 896
 897         @Test
 898         public void getAppThumbnailForMediaTypePngTest()
 899         {
 900
 901                 EPApp app = new EPApp();
 902                 app.setName("Test");
 903                 app.setImageUrl("test");
 904                 app.setDescription("test");
 905                 app.setNotes("test");
 906                 app.setUrl("test");
 907                 app.setId((long) 1);
 908                 app.setAppType(1);
 909                 app.setImageUrl("www.ecomp.png");
 910                 app.setThumbnail(new byte[] {1, 6, 3});
 911                 Mockito.when(appService.getApp((long) 1)).thenReturn(app);
 912                 PowerMockito.mockStatic(MediaType.class);
 913                 HttpEntity<byte[]> response = appsController.getAppThumbnail(mockedRequest, (long) 1, mockedResponse);
 914                 assertEquals(response.getHeaders().getContentLength(), 3);
 915         }
 916
 917         @Test
 918         public void getUserAppsOrderBySortPrefIfUSerNullTest(){
 919                 List<EcompApp> listOfApps = new ArrayList<EcompApp>();
 920
 921                 EcompApp app = new EcompApp();
 922                 listOfApps.add(app);
 923                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(null);
 924                 assertNull(appsController.getUserAppsOrderBySortPref(mockedRequest, mockedResponse));
 925         }
 926
 927         @Test
 928         public void getUserAppsOrderBySortPrefTest(){
 929                 List<EcompApp> listOfApps = new ArrayList<EcompApp>();
 930
 931                 EcompApp app = new EcompApp();
 932                 listOfApps.add(app);
 933                 EPUser user = mockUser.mockEPUser();
 934                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 935                 Mockito.when(mockedRequest.getParameter("mparams")).thenReturn("");
 936                 Mockito.when(appService.transformAppsToEcompApps(appService.getAppsOrderByName(user))).thenReturn(listOfApps);
 937                 List<EcompApp> listOfActualApps =       appsController.getUserAppsOrderBySortPref(mockedRequest, mockedResponse);
 938                 assertEquals(listOfActualApps.size(), 1);
 939         }
 940
 941         @Test
 942         public void getUserAppsOrderBySortPrefIfusrSortPrefIsMTest(){
 943                 List<EcompApp> listOfApps = new ArrayList<EcompApp>();
 944
 945                 EcompApp app = new EcompApp();
 946                 listOfApps.add(app);
 947                 EPUser user = mockUser.mockEPUser();
 948                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 949                 Mockito.when(mockedRequest.getParameter("mparams")).thenReturn("M");
 950                 Mockito.when(appService.transformAppsToEcompApps(appService.getAppsOrderByName(user))).thenReturn(listOfApps);
 951                 List<EcompApp> listOfActualApps =       appsController.getUserAppsOrderBySortPref(mockedRequest, mockedResponse);
 952                 assertEquals(listOfActualApps.size(), 1);
 953         }
 954
 955 }