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

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