ecomp-portal-BE-common/src/test/java/org/onap/portalapp/portal/service/EPAppCommonServiceImplTest.java

   1 /*-
   2  * ============LICENSE_START==========================================
   3  * ONAP Portal
   4  * ===================================================================
   5  * Copyright (C) 2018 AT&T Intellectual Property. All rights reserved.
   6  * ===================================================================
   7  *
   8  * Unless otherwise specified, all software contained herein is licensed
   9  * under the Apache License, Version 2.0 (the "License");
  10  * you may not use this software except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *             http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  * Unless otherwise specified, all documentation contained herein is licensed
  22  * under the Creative Commons License, Attribution 4.0 Intl. (the "License");
  23  * you may not use this documentation except in compliance with the License.
  24  * You may obtain a copy of the License at
  25  *
  26  *             https://creativecommons.org/licenses/by/4.0/
  27  *
  28  * Unless required by applicable law or agreed to in writing, documentation
  29  * distributed under the License is distributed on an "AS IS" BASIS,
  30  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  31  * See the License for the specific language governing permissions and
  32  * limitations under the License.
  33  *
  34  * ============LICENSE_END============================================
  35  *
  36  *
  37  */
  38 package org.onap.portalapp.portal.service;
  39
  40 import static org.junit.Assert.assertEquals;
  41 import static org.junit.Assert.assertNull;
  42
  43 import java.util.ArrayList;
  44 import java.util.HashMap;
  45 import java.util.List;
  46 import java.util.Map;
  47
  48 import javax.servlet.http.HttpServletResponse;
  49
  50 import org.hibernate.Session;
  51 import org.hibernate.SessionFactory;
  52 import org.hibernate.Transaction;
  53 import org.hibernate.criterion.Criterion;
  54 import org.hibernate.criterion.Restrictions;
  55 import org.junit.Before;
  56 import org.junit.Ignore;
  57 import org.junit.Test;
  58 import org.junit.runner.RunWith;
  59 import org.mockito.InjectMocks;
  60 import org.mockito.Matchers;
  61 import org.mockito.Mock;
  62 import org.mockito.Mockito;
  63 import org.mockito.MockitoAnnotations;
  64 import org.onap.portalapp.portal.core.MockEPUser;
  65 import org.onap.portalapp.portal.domain.AdminUserApp;
  66 import org.onap.portalapp.portal.domain.AdminUserApplications;
  67 import org.onap.portalapp.portal.domain.AppIdAndNameTransportModel;
  68 import org.onap.portalapp.portal.domain.AppsResponse;
  69 import org.onap.portalapp.portal.domain.EPApp;
  70 import org.onap.portalapp.portal.domain.EPUser;
  71 import org.onap.portalapp.portal.domain.EPUserAppRolesRequest;
  72 import org.onap.portalapp.portal.domain.EPUserAppsManualSortPreference;
  73 import org.onap.portalapp.portal.domain.EPUserAppsSortPreference;
  74 import org.onap.portalapp.portal.domain.EPWidgetsManualSortPreference;
  75 import org.onap.portalapp.portal.domain.EcompApp;
  76 import org.onap.portalapp.portal.domain.UserRole;
  77 import org.onap.portalapp.portal.domain.UserRoles;
  78 import org.onap.portalapp.portal.ecomp.model.AppCatalogItem;
  79 import org.onap.portalapp.portal.transport.EPAppsManualPreference;
  80 import org.onap.portalapp.portal.transport.EPAppsSortPreference;
  81 import org.onap.portalapp.portal.transport.EPDeleteAppsManualSortPref;
  82 import org.onap.portalapp.portal.transport.EPWidgetsSortPreference;
  83 import org.onap.portalapp.portal.transport.FieldsValidator;
  84 import org.onap.portalapp.portal.transport.FunctionalMenuItem;
  85 import org.onap.portalapp.portal.transport.LocalRole;
  86 import org.onap.portalapp.portal.transport.OnboardingApp;
  87 import org.onap.portalapp.portal.utils.EPCommonSystemProperties;
  88 import org.onap.portalapp.portal.utils.EcompPortalUtils;
  89 import org.onap.portalapp.portal.utils.PortalConstants;
  90 import org.onap.portalsdk.core.onboarding.util.PortalApiConstants;
  91 import org.onap.portalsdk.core.onboarding.util.PortalApiProperties;
  92 import org.onap.portalsdk.core.service.DataAccessService;
  93 import org.onap.portalsdk.core.service.DataAccessServiceImpl;
  94 import org.onap.portalsdk.core.util.SystemProperties;
  95 import org.powermock.api.mockito.PowerMockito;
  96 import org.powermock.core.classloader.annotations.PowerMockIgnore;
  97 import org.powermock.core.classloader.annotations.PrepareForTest;
  98 import org.powermock.modules.junit4.PowerMockRunner;
  99
 100 import com.att.nsa.apiClient.credentials.ApiCredential;
 101 import com.att.nsa.cambria.client.CambriaClientBuilders;
 102 import com.att.nsa.cambria.client.CambriaIdentityManager;
 103
 104 @RunWith(PowerMockRunner.class)
 105 @PowerMockIgnore({ "org.apache.http.conn.ssl.*", "javax.net.ssl.*", "javax.crypto.*" })
 106 @PrepareForTest({ EcompPortalUtils.class, PortalApiProperties.class, PortalApiConstants.class, SystemProperties.class,
 107                 PortalConstants.class, EPCommonSystemProperties.class })
 108 public class EPAppCommonServiceImplTest {
 109
 110         @Mock
 111         DataAccessService dataAccessService = new DataAccessServiceImpl();
 112
 113         @Mock
 114         AdminRolesServiceImpl adminRolesServiceImpl = new AdminRolesServiceImpl();
 115
 116         /*@Mock
 117         EPAppServiceImpl epAppServiceImpl = new EPAppServiceImpl();*/
 118
 119         @Mock
 120         SessionFactory sessionFactory;
 121
 122         @Mock
 123         Session session;
 124
 125         @Mock
 126         Transaction transaction;
 127
 128         NullPointerException nullPointerException = new NullPointerException();
 129
 130         @Before
 131         public void setup() {
 132                 MockitoAnnotations.initMocks(this);
 133                 Mockito.when(sessionFactory.openSession()).thenReturn(session);
 134                 Mockito.when(session.beginTransaction()).thenReturn(transaction);
 135         }
 136
 137         MockEPUser mockUser = new MockEPUser();
 138
 139         String ECOMP_APP_ID = "1";
 140         String SUPER_ADMIN_ROLE_ID = "1";
 141         String ACCOUNT_ADMIN_ROLE_ID = "999";
 142         String RESTRICTED_APP_ROLE_ID = "900";
 143
 144         @InjectMocks
 145         EPAppCommonServiceImpl epAppCommonServiceImpl = new EPAppCommonServiceImpl();
 146
 147         public EPApp mockApp() {
 148                 EPApp app = new EPApp();
 149                 app.setName("Test");
 150                 app.setImageUrl("test");
 151                 app.setDescription("test");
 152                 app.setNotes("test");
 153                 app.setUrl("test");
 154                 app.setId((long) 1);
 155                 app.setAppRestEndpoint("test");
 156                 app.setAlternateUrl("test");
 157                 app.setName("test");
 158                 app.setMlAppName("test");
 159                 app.setMlAppAdminId("test");
 160                 app.setUsername("test");
 161                 app.setAppPassword("test");
 162                 app.setOpen(false);
 163                 app.setEnabled(false);
 164                 app.setCentralAuth(true);
 165                 app.setUebKey("test");
 166                 app.setUebSecret("test");
 167                 app.setUebTopicName("test");
 168                 app.setAppType(1);
 169                 return app;
 170         }
 171
 172         @Test
 173         public void getUserAsAdminAppsTest() {
 174                 EPApp mockApp = mockApp();
 175                 EPApp mockApp2 = mockApp();
 176                 mockApp2.setId(2l);
 177                 EPUser user = mockUser.mockEPUser();
 178                 List<EPApp> expected = new ArrayList<>();
 179                 expected.add(mockApp);
 180                 expected.add(mockApp2);
 181                 String sql = "SELECT * FROM FN_APP join FN_USER_ROLE ON FN_USER_ROLE.APP_ID=FN_APP.APP_ID where "
 182                                 + "FN_USER_ROLE.USER_ID=" + user.getId() + " AND FN_USER_ROLE.ROLE_ID=" + ACCOUNT_ADMIN_ROLE_ID
 183                                 + " AND FN_APP.ENABLED = 'Y'";
 184                 Mockito.when(dataAccessService.executeSQLQuery(sql, EPApp.class, null)).thenReturn(expected);
 185                 Mockito.when(adminRolesServiceImpl.isAccountAdmin(user)).thenReturn(true);
 186                 List<EPApp> actual = epAppCommonServiceImpl.getUserAsAdminApps(user);
 187                 assertEquals(expected, actual);
 188         }
 189
 190         @Test
 191         public void getUserAsAdminAppsTestException() {
 192                 List<EPApp> expected = new ArrayList<>();
 193                 EPUser user = mockUser.mockEPUser();
 194                 String sql = "SELECT * FROM FN_APP join FN_USER_ROLE ON FN_USER_ROLE.APP_ID=FN_APP.APP_ID where "
 195                                 + "FN_USER_ROLE.USER_ID=" + user.getId() + " AND FN_USER_ROLE.ROLE_ID=" + ACCOUNT_ADMIN_ROLE_ID
 196                                 + " AND FN_APP.ENABLED = 'Y'";
 197                 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeSQLQuery(sql, EPApp.class, null);
 198                 Mockito.when(adminRolesServiceImpl.isAccountAdmin(user)).thenReturn(false);
 199                 List<EPApp> actual = epAppCommonServiceImpl.getUserAsAdminApps(user);
 200                 assertEquals(expected, actual);
 201         }
 202
 203         @Test
 204         public void getUserByOrgUserIdAsAdminAppsTest() {
 205                 EPApp mockApp = mockApp();
 206                 EPApp mockApp2 = mockApp();
 207                 mockApp2.setId(2l);
 208                 EPUser user = mockUser.mockEPUser();
 209                 List<EPApp> expected = new ArrayList<>();
 210                 expected.add(mockApp);
 211                 expected.add(mockApp2);
 212                 String format = "SELECT * FROM FN_APP app INNER JOIN FN_USER_ROLE userrole ON userrole.APP_ID=app.APP_ID "
 213                                 + "INNER JOIN FN_USER user on user.USER_ID = userrole.USER_ID "
 214                                 + "WHERE user.org_user_id = '%s' AND userrole.ROLE_ID=" + ACCOUNT_ADMIN_ROLE_ID
 215                                 + " AND FN_APP.ENABLED = 'Y'";
 216                 String sql = String.format(format, user.getOrgUserId());
 217                 Mockito.when(dataAccessService.executeSQLQuery(sql, EPApp.class, null)).thenReturn(expected);
 218                 List<EPApp> actual = epAppCommonServiceImpl.getUserByOrgUserIdAsAdminApps(user.getOrgUserId());
 219                 assertEquals(expected, actual);
 220         }
 221
 222         @Test
 223         public void getUserByOrgUserIdAsAdminAppsTest1() {
 224                 EPApp mockApp = mockApp();
 225                 EPApp mockApp2 = mockApp();
 226                 mockApp2.setId(2l);
 227                 EPUser user = mockUser.mockEPUser();
 228                 List<EPApp> expected = new ArrayList<>();
 229                 expected.add(mockApp);
 230                 expected.add(mockApp2);
 231                 String format = "SELECT * FROM FN_APP app INNER JOIN FN_USER_ROLE userrole ON userrole.APP_ID=app.APP_ID "
 232                                 + "INNER JOIN FN_USER user on user.USER_ID = userrole.USER_ID "
 233                                 + "WHERE user.org_user_id = '%s' AND userrole.ROLE_ID=" + ACCOUNT_ADMIN_ROLE_ID
 234                                 + " AND FN_APP.ENABLED = 'Y'";
 235                 String sql = String.format(format, user.getOrgUserId());
 236                 Mockito.when(dataAccessService.executeSQLQuery(sql, EPApp.class, null)).thenReturn(expected);
 237                 List<EPApp> actual = epAppCommonServiceImpl.getUserByOrgUserIdAsAdminApps(user.getOrgUserId());
 238                 assertEquals(expected, actual);
 239         }
 240
 241         @Test
 242         public void getUserByOrgUserIdAsAdminAppsTestException() {
 243                 EPUser user = mockUser.mockEPUser();
 244                 String format = "SELECT * FROM FN_APP app INNER JOIN FN_USER_ROLE userrole ON userrole.APP_ID=app.APP_ID "
 245                                 + "INNER JOIN FN_USER user on user.USER_ID = userrole.USER_ID "
 246                                 + "WHERE user.org_user_id = '%s' AND userrole.ROLE_ID=" + ACCOUNT_ADMIN_ROLE_ID
 247                                 + " AND FN_APP.ENABLED = 'Y'";
 248                 String sql = String.format(format, user.getOrgUserId());
 249                 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeSQLQuery(sql, EPApp.class, null);
 250                 List<EPApp> actual = epAppCommonServiceImpl.getUserByOrgUserIdAsAdminApps(user.getOrgUserId());
 251                 assertNull(actual);
 252         }
 253
 254         @SuppressWarnings("deprecation")
 255         @Test
 256         public void getAppsFullListTest() {
 257                 EPApp mockApp = mockApp();
 258                 EPApp mockApp2 = mockApp();
 259                 mockApp2.setId(2l);
 260                 List<EPApp> expected = new ArrayList<>();
 261                 expected.add(mockApp);
 262                 expected.add(mockApp2);
 263                 Mockito.when(dataAccessService.getList(EPApp.class, null)).thenReturn(expected);
 264                 List<EPApp> actual = epAppCommonServiceImpl.getAppsFullList();
 265                 assertEquals(expected, actual);
 266
 267         }
 268
 269         @Test
 270         public void getEcompAppAppsFullListTest() {
 271                 List<EcompApp> expected = new ArrayList<>();
 272                 List<EcompApp> actual = epAppCommonServiceImpl.getEcompAppAppsFullList();
 273                 assertEquals(expected, actual);
 274         }
 275
 276         @Test
 277         public void transformAppsToEcompAppsTest() {
 278                 EPApp mockApp = mockApp();
 279                 EPApp mockApp2 = mockApp();
 280                 mockApp2.setId(2l);
 281                 List<EPApp> epAppsList = new ArrayList<>();
 282                 epAppsList.add(mockApp);
 283                 epAppsList.add(mockApp2);
 284                 List<EcompApp> expected = new ArrayList<>();
 285                 EcompApp ecompApp = new EcompApp();
 286                 ecompApp.setName("test1");
 287                 EcompApp ecompApp2 = new EcompApp();
 288                 ecompApp2.setName("test2");
 289                 expected.add(ecompApp);
 290                 expected.add(ecompApp2);
 291                 List<EcompApp> actual = epAppCommonServiceImpl.transformAppsToEcompApps(epAppsList);
 292                 assertEquals(expected.size(), actual.size());
 293         }
 294
 295         @SuppressWarnings({ "unchecked", "deprecation" })
 296         @Test
 297         public void getAllAppsForAllTest() {
 298                 EPApp mockApp = mockApp();
 299                 EPApp mockApp2 = mockApp();
 300                 mockApp2.setId(2l);
 301                 List<EPApp> appsList = new ArrayList<>();
 302                 appsList.add(mockApp);
 303                 appsList.add(mockApp2);
 304                 List<AppsResponse> expected = new ArrayList<>();
 305                 AppsResponse appResponse1 = new AppsResponse(mockApp.getId(), mockApp.getName(), mockApp.isRestrictedApp(),
 306                                 mockApp.getEnabled());
 307                 AppsResponse appResponse2 = new AppsResponse(mockApp2.getId(), mockApp2.getName(), mockApp2.isRestrictedApp(),
 308                                 mockApp2.getEnabled());
 309                 expected.add(appResponse1);
 310                 expected.add(appResponse2);
 311                 Mockito.when((List<EPApp>) dataAccessService.getList(EPApp.class, " where id != " + ECOMP_APP_ID, "name", null))
 312                                 .thenReturn(appsList);
 313                 List<AppsResponse> actual = epAppCommonServiceImpl.getAllApps(true);
 314                 assertEquals(expected.size(), actual.size());
 315         }
 316
 317         @SuppressWarnings({ "unchecked", "deprecation" })
 318         @Test
 319         public void getAllAppsIsNotAllTest() {
 320                 EPApp mockApp = mockApp();
 321                 EPApp mockApp2 = mockApp();
 322                 mockApp2.setId(2l);
 323                 List<EPApp> appsList = new ArrayList<>();
 324                 appsList.add(mockApp);
 325                 appsList.add(mockApp2);
 326                 List<AppsResponse> expected = new ArrayList<>();
 327                 AppsResponse appResponse1 = new AppsResponse(mockApp.getId(), mockApp.getName(), mockApp.isRestrictedApp(),
 328                                 mockApp.getEnabled());
 329                 AppsResponse appResponse2 = new AppsResponse(mockApp2.getId(), mockApp2.getName(), mockApp2.isRestrictedApp(),
 330                                 mockApp2.getEnabled());
 331                 expected.add(appResponse1);
 332                 expected.add(appResponse2);
 333                 Mockito.when((List<EPApp>) dataAccessService.getList(EPApp.class,
 334                                 " where ( enabled = 'Y' or id = " + ECOMP_APP_ID + ")", "name", null)).thenReturn(appsList);
 335                 List<AppsResponse> actual = epAppCommonServiceImpl.getAllApps(false);
 336                 assertEquals(expected.size(), actual.size());
 337         }
 338
 339         @Test
 340         public void getAppTest() {
 341                 EPApp expected = mockApp();
 342                 Mockito.when((EPApp) dataAccessService.getDomainObject(EPApp.class, expected.getId(), null))
 343                                 .thenReturn(expected);
 344                 EPApp actual = epAppCommonServiceImpl.getApp(expected.getId());
 345                 assertEquals(expected, actual);
 346         }
 347
 348         @Test
 349         public void getAppExceptionTest() {
 350                 EPApp expected = mockApp();
 351                 Mockito.doThrow(new NullPointerException()).when(dataAccessService).getDomainObject(EPApp.class,
 352                                 expected.getId(), null);
 353                 EPApp actual = epAppCommonServiceImpl.getApp(expected.getId());
 354                 assertNull(actual);
 355         }
 356
 357         @SuppressWarnings("unchecked")
 358         @Test
 359         public void getAppDetailTest() {
 360                 EPApp expected = mockApp();
 361                 List<EPApp> appList = new ArrayList<>();
 362                 appList.add(expected);
 363                 final Map<String, String> params = new HashMap<String, String>();
 364                 params.put("appName", expected.getName());
 365                 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getMyloginAppDetails", params, null))
 366                                 .thenReturn(appList);
 367                 EPApp actual = epAppCommonServiceImpl.getAppDetail(expected.getName());
 368                 assertEquals(expected, actual);
 369         }
 370
 371         @Test
 372         public void getAppDetailExceptionTest() {
 373                 EPApp expected = mockApp();
 374                 List<EPApp> appList = new ArrayList<>();
 375                 appList.add(expected);
 376                 final Map<String, String> params = new HashMap<String, String>();
 377                 params.put("appName", expected.getName());
 378                 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery("getMyloginAppDetails",
 379                                 params, null);
 380                 EPApp actual = epAppCommonServiceImpl.getAppDetail(expected.getName());
 381                 assertNull(actual);
 382         }
 383
 384         @Test
 385         public void getUserProfile() {
 386                 EPUser user = mockUser.mockEPUser();
 387                 final Map<String, String> params = new HashMap<>();
 388                 params.put("org_user_id", user.getOrgUserId());
 389                 List<UserRole> userRoleList = new ArrayList<>();
 390                 UserRole userRole = new UserRole();
 391                 userRole.setFirstName("GuestT");
 392                 userRole.setLastName("GuestT");
 393                 userRole.setOrgUserId("guestT");
 394                 userRole.setRoleId(1l);
 395                 userRole.setRoleName("Test");
 396                 userRole.setUser_Id(-1l);
 397                 userRoleList.add(userRole);
 398                 UserRoles expected = new UserRoles(userRole);
 399                 Mockito.when(dataAccessService.executeNamedQuery("getUserRoles", params, null)).thenReturn(userRoleList);
 400                 UserRoles actual = epAppCommonServiceImpl.getUserProfile(user.getOrgUserId());
 401                 assertEquals(expected.getOrgUserId(), actual.getOrgUserId());
 402         }
 403
 404         @Test
 405         public void getUserProfileNullTest() {
 406                 EPUser user = mockUser.mockEPUser();
 407                 final Map<String, String> params = new HashMap<>();
 408                 params.put("org_user_id", user.getOrgUserId());
 409                 List<UserRole> userRoleList = new ArrayList<>();
 410                 Mockito.when(dataAccessService.executeNamedQuery("getUserRoles", params, null)).thenReturn(userRoleList);
 411                 UserRoles actual = epAppCommonServiceImpl.getUserProfile(user.getOrgUserId());
 412                 assertNull(actual);
 413         }
 414
 415         @Test
 416         public void getUserProfileNormalizedTest() {
 417                 EPUser user = mockUser.mockEPUser();
 418                 user.setGuest(true);
 419                 user.setLoginId("guestT");
 420                 final Map<String, String> params = new HashMap<>();
 421                 params.put("org_user_id", user.getOrgUserId());
 422                 List<UserRole> userRoleList = new ArrayList<>();
 423                 UserRole userRole = new UserRole();
 424                 userRole.setFirstName("GuestT");
 425                 userRole.setLastName("GuestT");
 426                 userRole.setOrgUserId("guestT");
 427                 userRole.setRoleId(1l);
 428                 userRole.setRoleName("Test");
 429                 userRole.setUser_Id(-1l);
 430                 userRoleList.add(userRole);
 431                 UserRoles expected = new UserRoles(userRole);
 432                 Mockito.when(dataAccessService.executeNamedQuery("getUserRoles", params, null)).thenReturn(userRoleList);
 433                 UserRoles actual = epAppCommonServiceImpl.getUserProfileNormalized(user);
 434                 assertEquals(expected.getOrgUserId(), actual.getOrgUserId());
 435         }
 436
 437         @Test
 438         public void getRestrictedAppRolesTest() {
 439                 EPUser user = mockUser.mockEPUser();
 440                 EPApp mockApp = mockApp();
 441                 mockApp.setRestrictedApp(true);
 442                 user.setLoginId("guestT");
 443                 List<LocalRole> expected = new ArrayList<>();
 444                 LocalRole localRole = new LocalRole();
 445                 localRole.setRoleId(1);
 446                 localRole.setRolename("test1");
 447                 expected.add(localRole);
 448                 String sql = "SELECT ROLE_ID, ROLE_NAME from FN_ROLE where UPPER(ACTIVE_YN) = 'Y' AND ROLE_ID = '"
 449                                 + RESTRICTED_APP_ROLE_ID + "'";
 450                 Mockito.when(dataAccessService.executeSQLQuery(sql, LocalRole.class, null)).thenReturn(expected);
 451                 Mockito.when((EPApp) dataAccessService.getDomainObject(EPApp.class, mockApp.getId(), null)).thenReturn(mockApp);
 452                 List<LocalRole> actual = epAppCommonServiceImpl.getAppRoles(mockApp.getId());
 453                 assertEquals(expected, actual);
 454         }
 455
 456         @Test
 457         public void getPoralAppRolesTest() {
 458                 EPUser user = mockUser.mockEPUser();
 459                 EPApp mockApp = mockApp();
 460                 mockApp.setRestrictedApp(false);
 461                 mockApp.setId(1l);
 462                 user.setLoginId("guestT");
 463                 List<LocalRole> expected = new ArrayList<>();
 464                 LocalRole localRole = new LocalRole();
 465                 localRole.setRoleId(1);
 466                 localRole.setRolename("test1");
 467                 expected.add(localRole);
 468                 String sql = "SELECT ROLE_ID, ROLE_NAME from FN_ROLE where UPPER(ACTIVE_YN) = 'Y' AND APP_ID IS NULL";
 469                 Mockito.when(dataAccessService.executeSQLQuery(sql, LocalRole.class, null)).thenReturn(expected);
 470                 Mockito.when((EPApp) dataAccessService.getDomainObject(EPApp.class, mockApp.getId(), null)).thenReturn(mockApp);
 471                 List<LocalRole> actual = epAppCommonServiceImpl.getAppRoles(mockApp.getId());
 472                 assertEquals(expected, actual);
 473         }
 474
 475         @Test
 476         public void getNonPortalAndNonRestrictedAppRolesTest() {
 477                 EPUser user = mockUser.mockEPUser();
 478                 EPApp mockApp = mockApp();
 479                 mockApp.setRestrictedApp(false);
 480                 mockApp.setId(2l);
 481                 user.setLoginId("guestT");
 482                 List<LocalRole> expected = new ArrayList<>();
 483                 LocalRole localRole = new LocalRole();
 484                 localRole.setRoleId(1);
 485                 localRole.setRolename("test1");
 486                 expected.add(localRole);
 487                 String sql = "SELECT ROLE_ID, ROLE_NAME from FN_ROLE where UPPER(ACTIVE_YN) = 'Y' AND APP_ID = '"
 488                                 + mockApp.getId() + "'";
 489                 Mockito.when(dataAccessService.executeSQLQuery(sql, LocalRole.class, null)).thenReturn(expected);
 490                 Mockito.when((EPApp) dataAccessService.getDomainObject(EPApp.class, mockApp.getId(), null)).thenReturn(mockApp);
 491                 List<LocalRole> actual = epAppCommonServiceImpl.getAppRoles(mockApp.getId());
 492                 assertEquals(expected, actual);
 493         }
 494
 495         @Test
 496         public void getAdminAppsTest() {
 497                 EPUser user = mockUser.mockEPUser();
 498                 user.setId(1l);
 499                 List<AppIdAndNameTransportModel> expected = new ArrayList<>();
 500                 AppIdAndNameTransportModel appIdAndNameTransportModel = new AppIdAndNameTransportModel();
 501                 appIdAndNameTransportModel.setId(1l);
 502                 appIdAndNameTransportModel.setName("test1");
 503                 expected.add(appIdAndNameTransportModel);
 504                 Mockito.when(adminRolesServiceImpl.isAccountAdmin(user)).thenReturn(true);
 505                 String format = "SELECT app.APP_ID, app.APP_NAME, app.APP_TYPE FROM FN_APP app inner join FN_USER_ROLE userrole ON userrole.APP_ID=app.APP_ID "
 506                                 + "where userrole.USER_ID = %d AND userrole.ROLE_ID=" + ACCOUNT_ADMIN_ROLE_ID
 507                                 + " AND (app.ENABLED = 'Y' OR app.APP_ID=1)";
 508                 String sql = String.format(format, user.getId());
 509                 Mockito.when(dataAccessService.executeSQLQuery(sql, AppIdAndNameTransportModel.class, null))
 510                                 .thenReturn(expected);
 511                 List<AppIdAndNameTransportModel> actual = epAppCommonServiceImpl.getAdminApps(user);
 512                 assertEquals(expected, actual);
 513         }
 514
 515         @Test
 516         public void getAdminAppsExceptionTest() {
 517                 EPUser user = mockUser.mockEPUser();
 518                 user.setId(1l);
 519                 List<AppIdAndNameTransportModel> expected = new ArrayList<>();
 520                 Mockito.when(adminRolesServiceImpl.isAccountAdmin(user)).thenReturn(true);
 521                 String format = "SELECT app.APP_ID, app.APP_NAME, app.APP_TYPE FROM FN_APP app inner join FN_USER_ROLE userrole ON userrole.APP_ID=app.APP_ID "
 522                                 + "where userrole.USER_ID = %d AND userrole.ROLE_ID=" + ACCOUNT_ADMIN_ROLE_ID
 523                                 + " AND (app.ENABLED = 'Y' OR app.APP_ID=1)";
 524                 String sql = String.format(format, user.getId());
 525                 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeSQLQuery(sql,
 526                                 AppIdAndNameTransportModel.class, null);
 527                 List<AppIdAndNameTransportModel> actual = epAppCommonServiceImpl.getAdminApps(user);
 528                 assertEquals(expected, actual);
 529         }
 530
 531         @Ignore
 532         @SuppressWarnings("unchecked")
 533         @Test
 534         public void addOnboardingAppUnKnownHostExceptionTest() throws Exception {
 535                 PowerMockito.mockStatic(PortalApiConstants.class);
 536                 PowerMockito.mockStatic(PortalApiProperties.class);
 537                 EPUser user = mockUser.mockEPUser();
 538                 List<EPApp> mockAppList = new ArrayList<>();
 539                 OnboardingApp onboardApp = new OnboardingApp();
 540                 onboardApp.setRestrictedApp(false);
 541                 onboardApp.name = "test1";
 542                 onboardApp.url = "http://test.com";
 543                 onboardApp.isOpen = false;
 544                 onboardApp.isEnabled = true;
 545                 onboardApp.username = "test123";
 546                 onboardApp.appPassword = "test123";
 547                 List<Criterion> restrictionsList = new ArrayList<Criterion>();
 548                 Criterion urlCrit = Restrictions.eq("url", onboardApp.url);
 549                 Criterion nameCrit = Restrictions.eq("name", onboardApp.name);
 550                 Criterion orCrit = Restrictions.or(urlCrit, nameCrit);
 551                 restrictionsList.add(orCrit);
 552                 List<String> uebList = new ArrayList<>();
 553                 uebList.add("localhost");
 554                 com.att.nsa.apiClient.credentials.ApiCredential apiCredential = new ApiCredential(user.getEmail(),
 555                                 "ECOMP Portal Owner");
 556                 CambriaIdentityManager mockIm = Mockito
 557                                 .spy(new CambriaClientBuilders.IdentityManagerBuilder().usingHosts(uebList).build());
 558                 Mockito.doReturn(apiCredential).when(mockIm).createApiKey(user.getEmail(), "ECOMP Portal Owner");
 559                 Mockito.when(PortalApiProperties.getProperty(PortalApiConstants.UEB_URL_LIST)).thenReturn("localhost");
 560                 Mockito.when((List<EPApp>) dataAccessService.getList(EPApp.class, null, restrictionsList, null))
 561                                 .thenReturn(mockAppList);
 562                 FieldsValidator expected = new FieldsValidator();
 563                 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
 564                 FieldsValidator actual = epAppCommonServiceImpl.addOnboardingApp(onboardApp, user);
 565                 assertEquals(expected, actual);
 566         }
 567
 568         @SuppressWarnings("unchecked")
 569         @Test
 570         public void modifyOnboardingAppTest() throws Exception {
 571                 EPUser user = mockUser.mockEPUser();
 572                 EPApp mockApp = mockApp();
 573                 mockApp.setName("test1");
 574                 mockApp.setId(2l);
 575                 mockApp.setUrl("http://test.com");
 576                 mockApp.setUsername("test123");
 577                 mockApp.setAppPassword("test123");
 578                 mockApp.setRestrictedApp(false);
 579                 mockApp.setEnabled(true);
 580                 mockApp.setOpen(false);
 581                 List<EPApp> mockAppList = new ArrayList<>();
 582                 mockAppList.add(mockApp);
 583                 OnboardingApp onboardApp = new OnboardingApp();
 584                 onboardApp.setRestrictedApp(false);
 585                 onboardApp.name = "test1";
 586                 onboardApp.id = 2l;
 587                 onboardApp.url = "http://test.com";
 588                 onboardApp.isOpen = false;
 589                 onboardApp.isEnabled = true;
 590                 onboardApp.thumbnail = "test123imgthumbnail";
 591                 onboardApp.username = "test123";
 592                 onboardApp.appPassword = "test123";
 593                 onboardApp.isCentralAuth=true;
 594                 onboardApp.myLoginsAppName="test123";
 595                 onboardApp.myLoginsAppOwner="test123";
 596
 597                 List<Criterion> restrictionsList1 = new ArrayList<Criterion>();
 598                 Criterion idCrit = Restrictions.eq("id", onboardApp.id);
 599                 Criterion urlCrit = Restrictions.eq("url", onboardApp.url);
 600                 Criterion nameCrit = Restrictions.eq("name", onboardApp.name);
 601                 Criterion orCrit = Restrictions.or(idCrit, urlCrit, nameCrit);
 602                 restrictionsList1.add(orCrit);
 603                 Mockito.when((List<EPApp>) dataAccessService.getList(EPApp.class, null, restrictionsList1, null))
 604                                 .thenReturn(mockAppList);
 605                 Mockito.when((EPApp) session.get(EPApp.class, onboardApp.id)).thenReturn(mockApp);
 606                 String sql = "SELECT m.menu_id, m.column_num, m.text, m.parent_menu_id, m.url, m.active_yn "
 607                                 + "FROM fn_menu_functional m, fn_menu_functional_roles r " + "WHERE m.menu_id = r.menu_id "
 608                                 + " AND r.app_id = '" + onboardApp.id + "' ";
 609                 List<Integer> roles = new ArrayList<>();
 610                 roles.add(1);
 611                 roles.add(2);
 612                 List<FunctionalMenuItem> menuItems = new ArrayList<>();
 613                 FunctionalMenuItem functionalMenuItem = new FunctionalMenuItem();
 614                 functionalMenuItem.setRestrictedApp(false);
 615                 functionalMenuItem.setUrl("http://test1.com");
 616                 functionalMenuItem.setRoles(roles);
 617                 menuItems.add(functionalMenuItem);
 618                 Mockito.when(dataAccessService.executeSQLQuery(sql, FunctionalMenuItem.class, null)).thenReturn(menuItems);
 619                 Mockito.when((FunctionalMenuItem) session.get(FunctionalMenuItem.class, functionalMenuItem.menuId))
 620                                 .thenReturn(functionalMenuItem);
 621                 FieldsValidator expected = new FieldsValidator();
 622                 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
 623                 FieldsValidator actual = epAppCommonServiceImpl.modifyOnboardingApp(onboardApp, user);
 624                 assertEquals(expected, actual);
 625         }
 626
 627         @Test
 628         public void saveWidgetsSortManualTest() {
 629                 EPUser user = mockUser.mockEPUser();
 630                 List<EPWidgetsManualSortPreference> mockEPManualWidgets = new ArrayList<>();
 631                 EPWidgetsManualSortPreference epWidgetsManualSortPreference = new EPWidgetsManualSortPreference();
 632                 epWidgetsManualSortPreference.setUserId(user.getId());
 633                 epWidgetsManualSortPreference.setWidgetCol(1);
 634                 epWidgetsManualSortPreference.setWidgetHeight(1);
 635                 epWidgetsManualSortPreference.setWidgetId(1l);
 636                 epWidgetsManualSortPreference.setWidgetRow(1);
 637                 epWidgetsManualSortPreference.setWidgetWidth(1);
 638                 mockEPManualWidgets.add(epWidgetsManualSortPreference);
 639                 final Map<String, Long> params = new HashMap<>();
 640                 params.put("userId", user.getId());
 641                 Mockito.when(dataAccessService.executeNamedQuery("userWidgetManualSortPrfQuery", params, null))
 642                                 .thenReturn(mockEPManualWidgets);
 643                 FieldsValidator expected = new FieldsValidator();
 644                 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
 645                 List<EPWidgetsSortPreference> epWidgetsSortPreferenceList = new ArrayList<>();
 646                 EPWidgetsSortPreference mockEPWidgetsSortPreference = new EPWidgetsSortPreference();
 647                 mockEPWidgetsSortPreference.setRow(2);
 648                 mockEPWidgetsSortPreference.setHeaderText("test");
 649                 mockEPWidgetsSortPreference.setSizeX(2);
 650                 mockEPWidgetsSortPreference.setSizeY(2);
 651                 mockEPWidgetsSortPreference.setWidgetid(2l);
 652                 mockEPWidgetsSortPreference.setWidgetIdentifier("test");
 653                 mockEPWidgetsSortPreference.setCol(2);
 654                 epWidgetsSortPreferenceList.add(mockEPWidgetsSortPreference);
 655                 FieldsValidator actual = epAppCommonServiceImpl.saveWidgetsSortManual(epWidgetsSortPreferenceList, user);
 656                 assertEquals(expected, actual);
 657         }
 658
 659         @Test
 660         public void saveWidgetsSortManualExistingRecordTest() {
 661                 EPUser user = mockUser.mockEPUser();
 662                 List<EPWidgetsManualSortPreference> mockEPManualWidgets = new ArrayList<>();
 663                 EPWidgetsManualSortPreference epWidgetsManualSortPreference = new EPWidgetsManualSortPreference();
 664                 epWidgetsManualSortPreference.setUserId(user.getId());
 665                 epWidgetsManualSortPreference.setWidgetCol(1);
 666                 epWidgetsManualSortPreference.setWidgetHeight(1);
 667                 epWidgetsManualSortPreference.setWidgetId(2l);
 668                 epWidgetsManualSortPreference.setWidgetRow(1);
 669                 epWidgetsManualSortPreference.setWidgetWidth(1);
 670                 mockEPManualWidgets.add(epWidgetsManualSortPreference);
 671                 final Map<String, Long> params = new HashMap<>();
 672                 params.put("userId", user.getId());
 673                 Mockito.when(dataAccessService.executeNamedQuery("userWidgetManualSortPrfQuery", params, null))
 674                                 .thenReturn(mockEPManualWidgets);
 675                 FieldsValidator expected = new FieldsValidator();
 676                 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
 677                 List<EPWidgetsSortPreference> epWidgetsSortPreferenceList = new ArrayList<>();
 678                 EPWidgetsSortPreference mockEPWidgetsSortPreference = new EPWidgetsSortPreference();
 679                 mockEPWidgetsSortPreference.setRow(2);
 680                 mockEPWidgetsSortPreference.setHeaderText("test");
 681                 mockEPWidgetsSortPreference.setSizeX(2);
 682                 mockEPWidgetsSortPreference.setSizeY(2);
 683                 mockEPWidgetsSortPreference.setWidgetid(2l);
 684                 mockEPWidgetsSortPreference.setWidgetIdentifier("test");
 685                 mockEPWidgetsSortPreference.setCol(2);
 686                 epWidgetsSortPreferenceList.add(mockEPWidgetsSortPreference);
 687                 FieldsValidator actual = epAppCommonServiceImpl.saveWidgetsSortManual(epWidgetsSortPreferenceList, user);
 688                 assertEquals(expected, actual);
 689         }
 690
 691         @Test
 692         public void deleteUserWidgetSortPrefTest() {
 693                 EPUser user = mockUser.mockEPUser();
 694                 List<EPWidgetsManualSortPreference> mockEPManualWidgets = new ArrayList<>();
 695                 EPWidgetsManualSortPreference epWidgetsManualSortPreference = new EPWidgetsManualSortPreference();
 696                 epWidgetsManualSortPreference.setUserId(user.getId());
 697                 epWidgetsManualSortPreference.setWidgetCol(1);
 698                 epWidgetsManualSortPreference.setWidgetHeight(1);
 699                 epWidgetsManualSortPreference.setWidgetId(2l);
 700                 epWidgetsManualSortPreference.setWidgetRow(1);
 701                 epWidgetsManualSortPreference.setWidgetWidth(1);
 702                 mockEPManualWidgets.add(epWidgetsManualSortPreference);
 703                 final Map<String, Long> params = new HashMap<>();
 704                 params.put("userId", user.getId());
 705                 Mockito.when(dataAccessService.executeNamedQuery("userWidgetManualSortPrfQuery", params, null))
 706                                 .thenReturn(mockEPManualWidgets);
 707                 FieldsValidator expected = new FieldsValidator();
 708                 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
 709                 List<EPWidgetsSortPreference> epWidgetsSortPreferenceList = new ArrayList<>();
 710                 EPWidgetsSortPreference mockEPWidgetsSortPreference = new EPWidgetsSortPreference();
 711                 mockEPWidgetsSortPreference.setRow(2);
 712                 mockEPWidgetsSortPreference.setHeaderText("test");
 713                 mockEPWidgetsSortPreference.setSizeX(2);
 714                 mockEPWidgetsSortPreference.setSizeY(2);
 715                 mockEPWidgetsSortPreference.setWidgetid(2l);
 716                 mockEPWidgetsSortPreference.setWidgetIdentifier("test");
 717                 mockEPWidgetsSortPreference.setCol(2);
 718                 epWidgetsSortPreferenceList.add(mockEPWidgetsSortPreference);
 719                 FieldsValidator actual = epAppCommonServiceImpl.deleteUserWidgetSortPref(epWidgetsSortPreferenceList, user);
 720                 assertEquals(expected, actual);
 721         }
 722
 723         @Test
 724         public void saveAppsSortPreferenceForNewUserTest() {
 725                 EPUser user = mockUser.mockEPUser();
 726                 List<EPUserAppsSortPreference> mockEPAppSortPrefList = new ArrayList<>();
 727                 final Map<String, Long> params = new HashMap<>();
 728                 params.put("userId", user.getId());
 729                 Mockito.when(dataAccessService.executeNamedQuery("userAppsSortPreferenceQuery", params, null))
 730                                 .thenReturn(mockEPAppSortPrefList);
 731                 FieldsValidator expected = new FieldsValidator();
 732                 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
 733                 EPAppsSortPreference mockEPAppsSortPreference = new EPAppsSortPreference();
 734                 mockEPAppsSortPreference.setIndex(1);
 735                 mockEPAppsSortPreference.setTitle("Last Used");
 736                 mockEPAppsSortPreference.setValue("L");
 737                 FieldsValidator actual = epAppCommonServiceImpl.saveAppsSortPreference(mockEPAppsSortPreference, user);
 738                 assertEquals(expected, actual);
 739         }
 740
 741         @Test
 742         public void saveAppsSortPreferenceUpdateTest() {
 743                 EPUser user = mockUser.mockEPUser();
 744                 List<EPUserAppsSortPreference> mockEPAppSortPrefList = new ArrayList<>();
 745                 EPUserAppsSortPreference mockEPAppSortPref = new EPUserAppsSortPreference();
 746                 mockEPAppSortPref.setSortPref("L");
 747                 mockEPAppSortPref.setId(2l);
 748                 mockEPAppSortPref.setUserId((int) (long) user.getId());
 749                 mockEPAppSortPrefList.add(mockEPAppSortPref);
 750                 final Map<String, Long> params = new HashMap<>();
 751                 params.put("userId", user.getId());
 752                 Mockito.when(dataAccessService.executeNamedQuery("userAppsSortPreferenceQuery", params, null))
 753                                 .thenReturn(mockEPAppSortPrefList);
 754                 FieldsValidator expected = new FieldsValidator();
 755                 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
 756                 EPAppsSortPreference mockEPAppsSortPreference = new EPAppsSortPreference();
 757                 mockEPAppsSortPreference.setIndex(1);
 758                 mockEPAppsSortPreference.setTitle("Last Used");
 759                 mockEPAppsSortPreference.setValue("L");
 760                 FieldsValidator actual = epAppCommonServiceImpl.saveAppsSortPreference(mockEPAppsSortPreference, user);
 761                 assertEquals(expected, actual);
 762         }
 763
 764         @Test
 765         public void saveAppsSortPreferenceExceptionTest() {
 766                 EPUser user = mockUser.mockEPUser();
 767                 final Map<String, Long> params = new HashMap<>();
 768                 params.put("userId", user.getId());
 769                 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
 770                 FieldsValidator expected = new FieldsValidator();
 771                 expected.setHttpStatusCode(500l);
 772                 //expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
 773                 EPAppsSortPreference mockEPAppsSortPreference = new EPAppsSortPreference();
 774                 mockEPAppsSortPreference.setIndex(1);
 775                 mockEPAppsSortPreference.setTitle("Last Used");
 776                 mockEPAppsSortPreference.setValue("L");
 777                 FieldsValidator actual = epAppCommonServiceImpl.saveAppsSortPreference(mockEPAppsSortPreference, user);
 778                 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
 779         }
 780
 781         @Test
 782         public void getUserAppsSortTypePreferenceTest() {
 783                 EPUser user = mockUser.mockEPUser();
 784                 final Map<String, Long> params = new HashMap<>();
 785                 List<EPUserAppsSortPreference> mockEPAppSortPrefList = new ArrayList<>();
 786                 EPUserAppsSortPreference mockEPAppSortPref = new EPUserAppsSortPreference();
 787                 mockEPAppSortPref.setSortPref("L");
 788                 mockEPAppSortPref.setId(2l);
 789                 mockEPAppSortPref.setUserId((int) (long) user.getId());
 790                 mockEPAppSortPrefList.add(mockEPAppSortPref);
 791                 params.put("userId", user.getId());
 792                 Mockito.when(dataAccessService.executeNamedQuery("userAppsSortPreferenceQuery", params, null))
 793                                 .thenReturn(mockEPAppSortPrefList);
 794                 String actual = epAppCommonServiceImpl.getUserAppsSortTypePreference(user);
 795                 assertEquals(mockEPAppSortPref.getSortPref(), actual);
 796         }
 797
 798         @Test
 799         public void getUserAppsSortTypePreferenceExceptionTest() {
 800                 EPUser user = mockUser.mockEPUser();
 801                 final Map<String, Long> params = new HashMap<>();
 802                 List<EPUserAppsSortPreference> mockEPAppSortPrefList = new ArrayList<>();
 803                 EPUserAppsSortPreference mockEPAppSortPref = new EPUserAppsSortPreference();
 804                 mockEPAppSortPref.setSortPref("L");
 805                 mockEPAppSortPref.setId(2l);
 806                 mockEPAppSortPref.setUserId((int) (long) user.getId());
 807                 mockEPAppSortPrefList.add(mockEPAppSortPref);
 808                 params.put("userId", user.getId());
 809                 Mockito.doThrow(new NullPointerException()).when(dataAccessService)
 810                                 .executeNamedQuery("userAppsSortPreferenceQuery", params, null);
 811                 String actual = epAppCommonServiceImpl.getUserAppsSortTypePreference(user);
 812                 assertNull(actual);
 813         }
 814
 815         @Test
 816         public void deleteUserAppSortManualTest() {
 817                 EPUser user = mockUser.mockEPUser();
 818                 EPApp mockApp = mockApp();
 819                 mockApp.setId(1l);
 820                 final Map<String, Long> params = new HashMap<>();
 821                 List<EPUserAppsManualSortPreference> epManualApps = new ArrayList<EPUserAppsManualSortPreference>();
 822                 EPUserAppsManualSortPreference epManualApp = new EPUserAppsManualSortPreference();
 823                 epManualApp.setAppId(mockApp.getId());
 824                 epManualApp.setAppManualSortOrder(1);
 825                 epManualApp.setId(1l);
 826                 epManualApp.setUserId(user.getId());
 827                 epManualApps.add(epManualApp);
 828                 params.put("userId", user.getId());
 829                 Mockito.when(dataAccessService.executeNamedQuery("userAppsManualSortPrfQuery", params, null)).thenReturn(epManualApps);
 830                 EPDeleteAppsManualSortPref delAppSortManual = new EPDeleteAppsManualSortPref();
 831                 delAppSortManual.setAppId(mockApp.getId());
 832                 delAppSortManual.setPending(false);
 833                 delAppSortManual.setSelect(false);
 834                 FieldsValidator actual = epAppCommonServiceImpl.deleteUserAppSortManual(delAppSortManual, user);
 835                 FieldsValidator expected = new FieldsValidator();
 836                 expected.setHttpStatusCode(200l);
 837                 assertEquals(expected, actual);
 838         }
 839
 840         @Test
 841         public void deleteUserAppSortManualExceptionTest() {
 842                 EPUser user = mockUser.mockEPUser();
 843                 EPApp mockApp = mockApp();
 844                 mockApp.setId(1l);
 845                 final Map<String, Long> params = new HashMap<>();
 846                 List<EPUserAppsManualSortPreference> epManualApps = new ArrayList<EPUserAppsManualSortPreference>();
 847                 EPUserAppsManualSortPreference epManualApp = new EPUserAppsManualSortPreference();
 848                 epManualApp.setAppId(mockApp.getId());
 849                 epManualApp.setAppManualSortOrder(1);
 850                 epManualApp.setId(1l);
 851                 epManualApp.setUserId(user.getId());
 852                 epManualApps.add(epManualApp);
 853                 params.put("userId", user.getId());
 854                 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery("userAppsManualSortPrfQuery", params, null);
 855                 EPDeleteAppsManualSortPref delAppSortManual = new EPDeleteAppsManualSortPref();
 856                 delAppSortManual.setAppId(mockApp.getId());
 857                 delAppSortManual.setPending(false);
 858                 delAppSortManual.setSelect(false);
 859                 FieldsValidator actual = epAppCommonServiceImpl.deleteUserAppSortManual(delAppSortManual, user);
 860                 FieldsValidator expected = new FieldsValidator();
 861                 expected.setHttpStatusCode(500l);
 862                 assertEquals(expected, actual);
 863         }
 864
 865     @SuppressWarnings("unchecked")
 866         @Test
 867         public void getAppDetailByAppNameTest(){
 868                 String appName = "test";
 869                 EPApp expectedResult = mockApp();
 870                 List<EPApp> appList = new ArrayList<>();
 871                 appList.add(expectedResult);
 872                 final Map<String, String> params = new HashMap<String, String>();
 873                 params.put("appName", expectedResult.getName());
 874                 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAppDetailsByAppName", params, null))
 875                                 .thenReturn(appList);
 876                 EPApp actualResult = epAppCommonServiceImpl.getAppDetailByAppName(appName);
 877                 assertEquals(expectedResult, actualResult);
 878         }
 879
 880     @SuppressWarnings("unchecked")
 881         @Test
 882         public void getAppDetailByAppNameExceptionTest(){
 883                 String appName = null;
 884                 EPApp expectedResult = null;
 885                 List<EPApp> appList = new ArrayList<>();
 886                 appList.add(expectedResult);
 887                 final Map<String, String> params = new HashMap<String, String>();
 888                 params.put("appName", null);
 889                 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAppDetailsByAppName", params, null))
 890                                 .thenReturn(appList);
 891                 EPApp actualResult = epAppCommonServiceImpl.getAppDetailByAppName(appName);
 892                 assertEquals(expectedResult, actualResult);
 893         }
 894
 895     @SuppressWarnings("unchecked")
 896         @Test
 897     public void getAppsForSuperAdminAndAccountAdminTest(){
 898         String sql = "SELECT app.APP_ID, app.APP_NAME, app.APP_TYPE FROM FN_APP app "
 899                                 + "where app.ENABLED = 'Y' AND app.app_type = 1";
 900         EPUser user = mockUser.mockEPUser();
 901         List<AppIdAndNameTransportModel> expected = null;
 902         Mockito.when(adminRolesServiceImpl.isSuperAdmin(user)).thenReturn(true);
 903         Mockito.when(adminRolesServiceImpl.isAccountAdmin(user)).thenReturn(true);
 904         List<AppIdAndNameTransportModel> actual = null;
 905         Mockito.when((List<AppIdAndNameTransportModel>) dataAccessService.executeSQLQuery(sql, AppIdAndNameTransportModel.class, null))
 906                                                                                                                                                         .thenReturn(actual);
 907         actual = epAppCommonServiceImpl.getAppsForSuperAdminAndAccountAdmin(user);
 908         assertEquals(expected, actual);
 909     }
 910
 911     @SuppressWarnings("unchecked")
 912         @Test
 913        public void getAppsForSuperAdminAndNotAccountAdminTest(){
 914         String sql = "SELECT app.APP_ID, app.APP_NAME, app.APP_TYPE FROM FN_APP app "
 915                                 + "where app.ENABLED = 'Y' AND app.app_type = 1";
 916         EPUser user = mockUser.mockEPUser();
 917         List<AppIdAndNameTransportModel> expected = new ArrayList<AppIdAndNameTransportModel>();
 918         Mockito.when(adminRolesServiceImpl.isSuperAdmin(user)).thenReturn(false);
 919         Mockito.when(adminRolesServiceImpl.isAccountAdmin(user)).thenReturn(true);
 920         List<AppIdAndNameTransportModel> actual = null;
 921         Mockito.when((List<AppIdAndNameTransportModel>) dataAccessService.executeSQLQuery(sql, AppIdAndNameTransportModel.class, null))
 922                                                                                                                                                         .thenReturn(actual);
 923         actual = epAppCommonServiceImpl.getAppsForSuperAdminAndAccountAdmin(user);
 924         assertEquals(expected, actual);
 925        }
 926
 927     @SuppressWarnings("unchecked")
 928         @Test
 929     public void getAppsForAdminAndAccountAdminTest(){
 930         String sql = "SELECT app.APP_ID, app.APP_NAME, app.APP_TYPE FROM FN_APP app "
 931                                 + "where app.ENABLED = 'Y' AND app.app_type = 1";
 932         EPUser user = mockUser.mockEPUser();
 933         List<AppIdAndNameTransportModel> expected = null;
 934         Mockito.when(adminRolesServiceImpl.isSuperAdmin(user)).thenReturn(true);
 935         List<AppIdAndNameTransportModel> actual = null;
 936         Mockito.when((List<AppIdAndNameTransportModel>) dataAccessService.executeSQLQuery(sql, AppIdAndNameTransportModel.class, null))
 937                                                                                                                                                         .thenReturn(actual);
 938         actual = epAppCommonServiceImpl.getAppsForSuperAdminAndAccountAdmin(user);
 939         assertEquals(expected, actual);
 940     }
 941
 942     @Test
 943     public void getAppsForSuperAdminAndAccountAdminExceptionTest(){
 944         String sql = "SELECT app.APP_ID, app.APP_NAME, app.APP_TYPE FROM FN_APP app "
 945                                 + "where app.ENABLED = 'Y' AND app.app_type = 1";
 946         EPUser user = mockUser.mockEPUser();
 947         List<AppIdAndNameTransportModel> expected = new ArrayList<AppIdAndNameTransportModel>();
 948         Mockito.when(adminRolesServiceImpl.isSuperAdmin(user)).thenReturn(true);
 949         List<AppIdAndNameTransportModel> actual = null;
 950         Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeSQLQuery(sql, AppIdAndNameTransportModel.class, null);
 951         actual = epAppCommonServiceImpl.getAppsForSuperAdminAndAccountAdmin(user);
 952         assertEquals(expected, actual);
 953     }
 954
 955     @Test
 956     public void getDataAccessServiceTest(){
 957         assertEquals(epAppCommonServiceImpl.getDataAccessService(), epAppCommonServiceImpl.getDataAccessService());
 958     }
 959
 960     @SuppressWarnings("unchecked")
 961         @Test
 962     public void getAppsAdminsTest(){
 963         List<AdminUserApplications> expected = new ArrayList<AdminUserApplications>();
 964         List<AdminUserApplications> actual = null;
 965         List<AdminUserApp> list = new ArrayList<AdminUserApp>();
 966         Map<String, String> params = new HashMap<>();
 967         params.put("accountAdminRoleId", ACCOUNT_ADMIN_ROLE_ID);
 968         Mockito.when((List<AdminUserApp>) dataAccessService.executeNamedQuery("getAppsAdmins", params, null)).thenReturn(list);
 969         actual = epAppCommonServiceImpl.getAppsAdmins();
 970         assertEquals(expected, actual);
 971     }
 972
 973     @Test
 974     public void getAppsAdminsExceptionTest(){
 975         List<AdminUserApplications> expected = null;
 976         List<AdminUserApplications> actual = null;
 977         Map<String, String> params = new HashMap<>();
 978         params.put("accountAdminRoleId", ACCOUNT_ADMIN_ROLE_ID);
 979         Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery("getAppsAdmins", params, null);
 980         actual = epAppCommonServiceImpl.getAppsAdmins();
 981         assertEquals(expected, actual);
 982     }
 983
 984         @SuppressWarnings("unchecked")
 985         @Test
 986     public void getAppsAdminsAggregateResultsTest(){
 987         List<AdminUserApplications> expected = new ArrayList<AdminUserApplications>();
 988         AdminUserApp adminUserApp = new AdminUserApp();
 989         AdminUserApplications adminUserApplications = new AdminUserApplications(adminUserApp);
 990         expected.add(adminUserApplications);
 991         List<AdminUserApplications> actual = null;
 992         List<AdminUserApp> list = new ArrayList<AdminUserApp>();
 993         AdminUserApp adminUserApp1 = new AdminUserApp();
 994         list.add(adminUserApp1);
 995         Map<String, String> params = new HashMap<>();
 996         params.put("accountAdminRoleId", ACCOUNT_ADMIN_ROLE_ID);
 997         Mockito.when((List<AdminUserApp>) dataAccessService.executeNamedQuery("getAppsAdmins", params, null)).thenReturn(list);
 998         actual = epAppCommonServiceImpl.getAppsAdmins();
 999         assertEquals(expected.size(), actual.size());
1000     }
1001
1002         @SuppressWarnings("unchecked")
1003         @Test
1004         public void getUserAppsTest(){
1005                 String sql ="";
1006                 EPApp epApp = new EPApp();
1007                 epApp.setOpen(false);
1008                 List<EPApp> expected = new ArrayList<EPApp>();
1009                 List<EPApp> list = new ArrayList<EPApp>();
1010                 EPUser epUser = new EPUser();
1011                 list.add(epApp);
1012                 Mockito.when((List<EPApp>) dataAccessService.executeSQLQuery(sql, EPApp.class, null)).thenReturn(list);
1013                 List<EPApp> actual = epAppCommonServiceImpl.getUserApps(epUser);
1014                 assertEquals(expected.size(), actual.size());
1015         }
1016
1017         @SuppressWarnings("unchecked")
1018         @Test
1019         public void getUserAppsUserGuestTest(){
1020                 String sql ="";
1021                 List<EPApp> expected = new ArrayList<EPApp>();
1022                 List<EPApp> list = new ArrayList<EPApp>();
1023                 EPUser epUser = new EPUser();
1024                 epUser.setGuest(true);
1025                 Mockito.when((List<EPApp>) dataAccessService.executeSQLQuery(sql, EPApp.class, null)).thenReturn(list);
1026                 List<EPApp> actual = epAppCommonServiceImpl.getUserApps(epUser);
1027                 assertEquals(expected.size(), actual.size());
1028         }
1029
1030         @SuppressWarnings("unchecked")
1031         @Test
1032         public void getPersAdminAppsTest(){
1033                 List<EPApp> expected = new ArrayList<EPApp>();
1034                 final Map<String, Long> params = new HashMap<>();
1035                 params.put("userId", (long)123);
1036                 EPUser epUser = new EPUser();
1037                 List<EPApp> list = new ArrayList<EPApp>();
1038                 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getPersAdminApps", params, null)).thenReturn(list);
1039                 List<EPApp> actual = epAppCommonServiceImpl.getPersAdminApps(epUser);
1040                 assertEquals(expected, actual);
1041         }
1042
1043         @SuppressWarnings("unchecked")
1044         @Test
1045         public void getPersUserAppsTest(){
1046                 List<EPApp> expected = new ArrayList<EPApp>();
1047                 EPUser epUser = new EPUser();
1048                 final Map<String, Long> params = new HashMap<>();
1049                 params.put("userId", (long)123);
1050                 List<EPApp> list = new ArrayList<EPApp>();
1051                 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getPersUserApps", params, null)).thenReturn(list);
1052                 List<EPApp> actual = epAppCommonServiceImpl.getPersUserApps(epUser);
1053                 assertEquals(expected, actual);
1054         }
1055
1056         @SuppressWarnings("unchecked")
1057         @Test
1058         public void getUserAppCatalogTest(){
1059                 List<AppCatalogItem> expected = new ArrayList<AppCatalogItem>();
1060                 EPUser epUser = new EPUser();
1061                 final Map<String, Long> params = new HashMap<>();
1062                 params.put("userId", (long)123);
1063                 List<AppCatalogItem> list = new ArrayList<AppCatalogItem>();
1064                 Mockito.when((List<AppCatalogItem>) dataAccessService.executeNamedQuery("getUserAppCatalog", params, null)).thenReturn(list);
1065                 List<AppCatalogItem> actual = epAppCommonServiceImpl.getUserAppCatalog(epUser);
1066                 assertEquals(expected, actual);
1067         }
1068
1069         @SuppressWarnings("unchecked")
1070         @Test
1071         public void getAdminAppCatalogTest(){
1072                 List<AppCatalogItem> expected = new ArrayList<AppCatalogItem>();
1073                 EPUser epUser = new EPUser();
1074                 final Map<String, Long> params = new HashMap<>();
1075                 params.put("userId", (long)123);
1076                 List<AppCatalogItem> list = new ArrayList<AppCatalogItem>();
1077                 Mockito.when((List<AppCatalogItem>) dataAccessService.executeNamedQuery("getAdminAppCatalog", params, null)).thenReturn(list);
1078                 List<AppCatalogItem> actual = epAppCommonServiceImpl.getAdminAppCatalog(epUser);
1079                 assertEquals(expected, actual);
1080         }
1081
1082         @SuppressWarnings("unchecked")
1083         @Test
1084         public void getAppsOrderByNameTest(){
1085                 List<EPApp> expected = new ArrayList<EPApp>();
1086                 EPUser epUser = new EPUser();
1087                 List<EPApp> list = new ArrayList<EPApp>();
1088                 final Map<String, Long> params = new HashMap<>();
1089                 params.put("userId", (long)123);
1090                 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1091                 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getPersAdminAppsOrderByName", params, null)).thenReturn(list);
1092                 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByName(epUser);
1093                 assertEquals(expected, actual);
1094         }
1095
1096         @SuppressWarnings("unchecked")
1097         @Test
1098         public void getAppsOrderByNameNotSuperAdminTest(){
1099                 List<EPApp> expected = new ArrayList<EPApp>();
1100                 EPUser epUser = new EPUser();
1101                 List<EPApp> list = new ArrayList<EPApp>();
1102                 final Map<String, Long> params = new HashMap<>();
1103                 params.put("userId", (long)123);
1104                 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(false);
1105                 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getPersAdminAppsOrderByName", params, null)).thenReturn(list);
1106                 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByName(epUser);
1107                 assertEquals(expected, actual);
1108         }
1109
1110         @Test
1111         public void getAppsOrderByNameExceptionTest(){
1112                 List<EPApp> expected = null;
1113                 EPUser epUser = new EPUser();
1114                 final Map<String, Long> params = new HashMap<>();
1115                 params.put("userId", null);
1116                 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1117                 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
1118                 //Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap())).thenReturn(list);
1119                 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByName(epUser);
1120                 assertEquals(expected, actual);
1121         }
1122
1123         @SuppressWarnings("unchecked")
1124         @Test
1125         public void getAppsOrderByLastUsedTest(){
1126                 List<EPApp> expected = new ArrayList<EPApp>();
1127                 EPUser epUser = new EPUser();
1128                 List<EPApp> list = new ArrayList<EPApp>();
1129                 final Map<String, Long> params = new HashMap<>();
1130                 params.put("userId", (long)123);
1131                 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1132                 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAdminAppsOrderByLastUsed", params, null)).thenReturn(list);
1133                 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByLastUsed(epUser);
1134                 assertEquals(expected, actual);
1135         }
1136
1137         @SuppressWarnings("unchecked")
1138         @Test
1139         public void getAppsOrderByLastUsedNotSuperAdminTest(){
1140                 List<EPApp> expected = new ArrayList<EPApp>();
1141                 EPUser epUser = new EPUser();
1142                 List<EPApp> list = new ArrayList<EPApp>();
1143                 final Map<String, Long> params = new HashMap<>();
1144                 params.put("userId", (long)123);
1145                 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(false);
1146                 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAdminAppsOrderByLastUsed", params, null)).thenReturn(list);
1147                 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByLastUsed(epUser);
1148                 assertEquals(expected, actual);
1149         }
1150
1151         @Test
1152         public void getAppsOrderByLastUsedExceptionTest(){
1153                 List<EPApp> expected = new ArrayList<EPApp>();
1154                 EPUser epUser = new EPUser();
1155                 final Map<String, Long> params = new HashMap<>();
1156                 params.put("userId", null);
1157                 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
1158                 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByLastUsed(epUser);
1159                 assertEquals(expected, actual);
1160         }
1161
1162         @SuppressWarnings("unchecked")
1163         @Test
1164         public void getAppsOrderByMostUsedTest(){
1165                 List<EPApp> expected = new ArrayList<EPApp>();
1166                 EPUser epUser = new EPUser();
1167                 List<EPApp> list = new ArrayList<EPApp>();
1168                 final Map<String, Long> params = new HashMap<>();
1169                 params.put("userId", (long)123);
1170                 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1171                 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAppsOrderByMostUsed", params, null)).thenReturn(list);
1172                 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByMostUsed(epUser);
1173                 assertEquals(expected, actual);
1174         }
1175
1176         @SuppressWarnings("unchecked")
1177         @Test
1178         public void getAppsOrderByMostUsedNotSuperAdminTest(){
1179                 List<EPApp> expected = new ArrayList<EPApp>();
1180                 EPUser epUser = new EPUser();
1181                 List<EPApp> list = new ArrayList<EPApp>();
1182                 final Map<String, Long> params = new HashMap<>();
1183                 params.put("userId", (long)123);
1184                 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(false);
1185                 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAppsOrderByMostUsed", params, null)).thenReturn(list);
1186                 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByMostUsed(epUser);
1187                 assertEquals(expected, actual);
1188         }
1189
1190         @Test
1191         public void getAppsOrderByMostUsedExceptionTest(){
1192                 List<EPApp> expected = new ArrayList<EPApp>();
1193                 EPUser epUser = new EPUser();
1194                 final Map<String, Long> params = new HashMap<>();
1195                 params.put("userId", null);
1196                 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
1197                 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByMostUsed(epUser);
1198                 assertEquals(expected, actual);
1199         }
1200
1201         @SuppressWarnings("unchecked")
1202         @Test
1203         public void getAppsOrderByManualTest(){
1204                 List<EPApp> expected = new ArrayList<EPApp>();
1205                 EPUser epUser = new EPUser();
1206                 List<EPApp> list = new ArrayList<EPApp>();
1207                 final Map<String, Long> params = new HashMap<>();
1208                 params.put("userId", (long)123);
1209                 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1210                 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAdminAppsOrderByManual", params, null)).thenReturn(list);
1211                 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByManual(epUser);
1212                 assertEquals(expected, actual);
1213         }
1214
1215         @SuppressWarnings("unchecked")
1216         @Test
1217         public void getAppsOrderByManualSuperAdminTest(){
1218                 List<EPApp> expected = new ArrayList<EPApp>();
1219                 EPUser epUser = new EPUser();
1220                 List<EPApp> list = new ArrayList<EPApp>();
1221                 final Map<String, Long> params = new HashMap<>();
1222                 params.put("userId", (long)123);
1223                 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(false);
1224                 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAdminAppsOrderByManual", params, null)).thenReturn(list);
1225                 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByManual(epUser);
1226                 assertEquals(expected, actual);
1227         }
1228
1229         @SuppressWarnings("unchecked")
1230         @Test
1231         public void getAppsOrderByManualExceptionTest(){
1232                 List<EPApp> expected = new ArrayList<EPApp>();
1233                 EPUser epUser = new EPUser();
1234                 List<EPApp> list = new ArrayList<EPApp>();
1235                 final Map<String, Long> params = new HashMap<>();
1236                 params.put("userId", null);
1237                 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1238                 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
1239                 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByManual(epUser);
1240                 assertEquals(expected, actual);
1241         }
1242
1243         @SuppressWarnings("deprecation")
1244         @Test
1245         public void getOnboardingAppsTest(){
1246                 List<EPApp> apps = new ArrayList<EPApp>();
1247                 List<OnboardingApp> expected = new ArrayList<OnboardingApp>();
1248                 Mockito.when(dataAccessService.getList(EPApp.class, " where id!=" + ECOMP_APP_ID, null, null)).thenReturn(apps);
1249                 List<OnboardingApp> actual = epAppCommonServiceImpl.getOnboardingApps();
1250                 assertEquals(expected, actual);
1251         }
1252
1253         @Test
1254         public void getEnabledNonOpenOnboardingAppsTest(){
1255                 List<OnboardingApp> expected = new ArrayList<OnboardingApp>();
1256                 List<OnboardingApp> actual = epAppCommonServiceImpl.getEnabledNonOpenOnboardingApps();
1257                 assertEquals(expected, actual);
1258         }
1259
1260         @Test
1261         public void addOnboardingAppTest(){
1262                 FieldsValidator expected = new FieldsValidator();
1263                 expected.setHttpStatusCode(400l);
1264                 EPUser epUser = new EPUser();
1265                 OnboardingApp onboardingApp = new OnboardingApp();
1266
1267                 onboardingApp.setRestrictedApp(true);
1268                 onboardingApp.isCentralAuth=false;
1269                 FieldsValidator actual = epAppCommonServiceImpl.addOnboardingApp(onboardingApp, epUser);
1270                 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
1271         }
1272
1273         @Test
1274         public void deleteOnboardingAppTest(){
1275                 FieldsValidator expected = new FieldsValidator();
1276                 expected.setHttpStatusCode(403l);
1277                 EPUser epUser = new EPUser();
1278                 Long appId = (long) 123;
1279                 OnboardingApp onboardingApp = new OnboardingApp();
1280                 onboardingApp.setRestrictedApp(true);
1281                 FieldsValidator actual = epAppCommonServiceImpl.deleteOnboardingApp(epUser, appId);
1282                 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
1283         }
1284
1285         @SuppressWarnings("unchecked")
1286         @Test
1287         public void deleteOnboardingAppSuperAdminTest(){
1288                 FieldsValidator expected = new FieldsValidator();
1289                 expected.setHttpStatusCode(200l);
1290                 EPUser epUser = new EPUser();
1291                 Long appId = (long) 123;
1292                 OnboardingApp onboardingApp = new OnboardingApp();
1293                 onboardingApp.setRestrictedApp(true);
1294                 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1295                 final Map<String, Long> params = new HashMap<>();
1296                 params.put("app_id", (long)123);
1297                 EPUserAppRolesRequest epUserAppRolesRequest = new EPUserAppRolesRequest();
1298                 epUserAppRolesRequest.setUserId((long)123);
1299                 List<EPUserAppRolesRequest> list= new ArrayList<>();
1300                 list.add(epUserAppRolesRequest);
1301                 Mockito.when((List<EPUserAppRolesRequest>) dataAccessService.executeNamedQuery("getRequestIdsForApp", params, null)).thenReturn(list);
1302                 FieldsValidator actual = epAppCommonServiceImpl.deleteOnboardingApp(epUser, appId);
1303                 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
1304         }
1305
1306         @Test(expected=NullPointerException.class)
1307         public void deleteOnboardingAppExceptionTest(){
1308                 FieldsValidator expected = new FieldsValidator();
1309                 expected.setHttpStatusCode(200l);
1310                 EPUser epUser = new EPUser();
1311                 //Long appId = (long) 123;
1312                 List<EPUserAppRolesRequest> epUserAppRolesRequestList= new ArrayList<>();
1313                 OnboardingApp onboardingApp = new OnboardingApp();
1314                 onboardingApp.setRestrictedApp(true);
1315                 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1316                 final Map<String, Long> params = new HashMap<>();
1317                 params.put("app_id", null);
1318                 Mockito.when(dataAccessService.executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap())).thenThrow(nullPointerException);
1319                 Mockito.when(dataAccessService.executeNamedQuery( "getRequestIdsForApp", params, null)).thenReturn(epUserAppRolesRequestList);
1320                 //Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
1321                 FieldsValidator actual = epAppCommonServiceImpl.deleteOnboardingApp(epUser, null);
1322                 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
1323         }
1324
1325         @SuppressWarnings("unchecked")
1326         @Test
1327         public void saveAppsSortManualAppIdNullTest(){
1328                 List<EPUserAppsManualSortPreference> epUserAppsManualSortPreferenceList = new ArrayList<EPUserAppsManualSortPreference>();
1329                 EPAppsManualPreference epAppsManualPreference = new EPAppsManualPreference();
1330                 epAppsManualPreference.setAddRemoveApps(true);
1331                 epAppsManualPreference.setAppid((long)123);
1332                 FieldsValidator expected = new FieldsValidator();
1333                 expected.setHttpStatusCode(200l);
1334                 final Map<String, Long> params = new HashMap<>();
1335                 params.put("userId", (long)123);
1336                 EPUser epUser = new EPUser();
1337                 List<EPAppsManualPreference> list = new ArrayList<EPAppsManualPreference>();
1338                 list.add(epAppsManualPreference);
1339                 Mockito.when(dataAccessService.executeNamedQuery("userAppsManualSortPrfQuery", params, null)).thenReturn(epUserAppsManualSortPreferenceList);
1340                 FieldsValidator actual = epAppCommonServiceImpl.saveAppsSortManual(list, epUser);
1341                 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
1342         }
1343
1344         @Test
1345         public void saveAppsSortManualExceptionTest(){
1346                 FieldsValidator expected = new FieldsValidator();
1347                 expected.setHttpStatusCode(500l);
1348                 final Map<String, Long> params = new HashMap<>();
1349                 params.put("userId", (long)123);
1350                 EPUser epUser = new EPUser();
1351                 List<EPAppsManualPreference> list = new ArrayList<EPAppsManualPreference>();
1352                 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
1353                 FieldsValidator actual = epAppCommonServiceImpl.saveAppsSortManual(list, epUser);
1354                 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
1355         }
1356
1357         @Test
1358         public void getUserProfileForLeftMenuNullListTest(){
1359                 UserRole userRole =new UserRole();
1360                 userRole.setFirstName("test");
1361                 UserRoles  expected = null;
1362                 UserRoles  actual = epAppCommonServiceImpl.getUserProfileForLeftMenu("123");
1363                 assertEquals(expected, actual);
1364         }
1365
1366         @Test
1367         public void getUserProfileForLeftMenuTest(){
1368                 final Map<String, String> params = new HashMap<>();
1369                 params.put("org_user_id", "test");
1370                 UserRole userRole =new UserRole();
1371                 userRole.setFirstName("test");
1372                 UserRoles  expected = null;
1373                 List<UserRole> list = new ArrayList<UserRole>();
1374                 list.add(userRole);
1375                 Mockito.when(dataAccessService.executeNamedQuery( "getUserRolesForLeftMenu", params, null)).thenReturn(list);
1376                 UserRoles  actual = epAppCommonServiceImpl.getUserProfileForLeftMenu("123");
1377                 assertEquals(expected, actual);
1378         }
1379
1380         @Test
1381         public void getUserProfileForRolesLeftMenuNullListTest(){
1382                 UserRoles expected = null;
1383                 List<UserRole> userRoleList = new ArrayList<UserRole>();
1384                 final Map<String, String> params = new HashMap<>();
1385                 params.put("org_user_id", "test");
1386                 Mockito.when(dataAccessService.executeNamedQuery( "getRolesForLeftMenu", params, null)).thenReturn(userRoleList);
1387                 UserRoles  actual = epAppCommonServiceImpl.getUserProfileForRolesLeftMenu("test");
1388                 assertEquals(expected, actual);
1389         }
1390
1391         @Test
1392         public void getUserProfileForRolesLeftMenuTest(){
1393                 UserRole userRole = new UserRole();
1394                 userRole.setRoleId((long)123);
1395                 userRole.setOrgUserId("test");
1396                 userRole.setUser_Id((long)1);
1397                 List<UserRole> userRoleList = new ArrayList<UserRole>();
1398                 userRoleList.add(userRole);
1399                 UserRoles expected = new UserRoles(userRole);
1400                 final Map<String, String> params = new HashMap<>();
1401                 params.put("org_user_id", "test");
1402                 Mockito.when(dataAccessService.executeNamedQuery( "getRolesForLeftMenu", params, null)).thenReturn(userRoleList);
1403                 UserRoles  actual = epAppCommonServiceImpl.getUserProfileForRolesLeftMenu("test");
1404                 assertEquals(expected.getOrgUserId(), actual.getOrgUserId());
1405         }
1406
1407         @Test
1408         public void getUserProfileNormalizedForLeftMenuNullListTest(){
1409                 EPUser epUser = new EPUser();
1410                 List<String> list = new ArrayList<String>();
1411                 list.add("Guest");
1412                 UserRole userRole = new UserRole();
1413                 userRole.setFirstName("GuestT");
1414                 userRole.setLastName("GuestT");
1415                 userRole.setOrgUserId("guestT");
1416                 userRole.setRoleId(1l);
1417                 userRole.setRoleName("Test");
1418                 userRole.setUser_Id(-1l);
1419                 UserRoles expected = new UserRoles(userRole);
1420                 expected.setRoles(list);
1421                 UserRoles actual = epAppCommonServiceImpl.getUserProfileNormalizedForLeftMenu(epUser);
1422                 assertEquals(expected.getRoles(), actual.getRoles());
1423         }
1424
1425         @Test
1426         public void getUserProfileNormalizedForRolesLeftMenuTest(){
1427                 EPUser epUser = new EPUser();
1428                 List<String> list = new ArrayList<String>();
1429                 list.add("Guest");
1430                 UserRole userRole = new UserRole();
1431                 userRole.setFirstName("GuestT");
1432                 userRole.setLastName("GuestT");
1433                 userRole.setOrgUserId("guestT");
1434                 userRole.setRoleId(1l);
1435                 userRole.setRoleName("Test");
1436                 userRole.setUser_Id(-1l);
1437                 UserRoles expected = new UserRoles(userRole);
1438                 expected.setRoles(list);
1439                 UserRoles actual = epAppCommonServiceImpl.getUserProfileNormalizedForRolesLeftMenu(epUser);
1440                 assertEquals(expected.getRoles(), actual.getRoles());
1441         }
1442 }