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