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

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