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

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