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