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