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