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