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                 List<Criterion> restrictionsList1 = new ArrayList<Criterion>();
 594                 Criterion idCrit = Restrictions.eq("id", onboardApp.id);
 595                 Criterion urlCrit = Restrictions.eq("url", onboardApp.url);
 596                 Criterion nameCrit = Restrictions.eq("name", onboardApp.name);
 597                 Criterion orCrit = Restrictions.or(idCrit, urlCrit, nameCrit);
 598                 restrictionsList1.add(orCrit);
 599                 Mockito.when((List<EPApp>) dataAccessService.getList(EPApp.class, null, restrictionsList1, null))
 600                                 .thenReturn(mockAppList);
 601                 Mockito.when((EPApp) session.get(EPApp.class, onboardApp.id)).thenReturn(mockApp);
 602                 String sql = "SELECT m.menu_id, m.column_num, m.text, m.parent_menu_id, m.url, m.active_yn "
 603                                 + "FROM fn_menu_functional m, fn_menu_functional_roles r " + "WHERE m.menu_id = r.menu_id "
 604                                 + " AND r.app_id = '" + onboardApp.id + "' ";
 605                 List<Integer> roles = new ArrayList<>();
 606                 roles.add(1);
 607                 roles.add(2);
 608                 List<FunctionalMenuItem> menuItems = new ArrayList<>();
 609                 FunctionalMenuItem functionalMenuItem = new FunctionalMenuItem();
 610                 functionalMenuItem.setRestrictedApp(false);
 611                 functionalMenuItem.setUrl("http://test1.com");
 612                 functionalMenuItem.setRoles(roles);
 613                 menuItems.add(functionalMenuItem);
 614                 Mockito.when(dataAccessService.executeSQLQuery(sql, FunctionalMenuItem.class, null)).thenReturn(menuItems);
 615                 Mockito.when((FunctionalMenuItem) session.get(FunctionalMenuItem.class, functionalMenuItem.menuId))
 616                                 .thenReturn(functionalMenuItem);
 617                 FieldsValidator expected = new FieldsValidator();
 618                 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
 619                 FieldsValidator actual = epAppCommonServiceImpl.modifyOnboardingApp(onboardApp, user);
 620                 assertEquals(expected, actual);
 621         }
 622
 623         @Test
 624         public void saveWidgetsSortManualTest() {
 625                 EPUser user = mockUser.mockEPUser();
 626                 List<EPWidgetsManualSortPreference> mockEPManualWidgets = new ArrayList<>();
 627                 EPWidgetsManualSortPreference epWidgetsManualSortPreference = new EPWidgetsManualSortPreference();
 628                 epWidgetsManualSortPreference.setUserId(user.getId());
 629                 epWidgetsManualSortPreference.setWidgetCol(1);
 630                 epWidgetsManualSortPreference.setWidgetHeight(1);
 631                 epWidgetsManualSortPreference.setWidgetId(1l);
 632                 epWidgetsManualSortPreference.setWidgetRow(1);
 633                 epWidgetsManualSortPreference.setWidgetWidth(1);
 634                 mockEPManualWidgets.add(epWidgetsManualSortPreference);
 635                 final Map<String, Long> params = new HashMap<>();
 636                 params.put("userId", user.getId());
 637                 Mockito.when(dataAccessService.executeNamedQuery("userWidgetManualSortPrfQuery", params, null))
 638                                 .thenReturn(mockEPManualWidgets);
 639                 FieldsValidator expected = new FieldsValidator();
 640                 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
 641                 List<EPWidgetsSortPreference> epWidgetsSortPreferenceList = new ArrayList<>();
 642                 EPWidgetsSortPreference mockEPWidgetsSortPreference = new EPWidgetsSortPreference();
 643                 mockEPWidgetsSortPreference.setRow(2);
 644                 mockEPWidgetsSortPreference.setHeaderText("test");
 645                 mockEPWidgetsSortPreference.setSizeX(2);
 646                 mockEPWidgetsSortPreference.setSizeY(2);
 647                 mockEPWidgetsSortPreference.setWidgetid(2l);
 648                 mockEPWidgetsSortPreference.setWidgetIdentifier("test");
 649                 mockEPWidgetsSortPreference.setCol(2);
 650                 epWidgetsSortPreferenceList.add(mockEPWidgetsSortPreference);
 651                 FieldsValidator actual = epAppCommonServiceImpl.saveWidgetsSortManual(epWidgetsSortPreferenceList, user);
 652                 assertEquals(expected, actual);
 653         }
 654
 655         @Test
 656         public void saveWidgetsSortManualExistingRecordTest() {
 657                 EPUser user = mockUser.mockEPUser();
 658                 List<EPWidgetsManualSortPreference> mockEPManualWidgets = new ArrayList<>();
 659                 EPWidgetsManualSortPreference epWidgetsManualSortPreference = new EPWidgetsManualSortPreference();
 660                 epWidgetsManualSortPreference.setUserId(user.getId());
 661                 epWidgetsManualSortPreference.setWidgetCol(1);
 662                 epWidgetsManualSortPreference.setWidgetHeight(1);
 663                 epWidgetsManualSortPreference.setWidgetId(2l);
 664                 epWidgetsManualSortPreference.setWidgetRow(1);
 665                 epWidgetsManualSortPreference.setWidgetWidth(1);
 666                 mockEPManualWidgets.add(epWidgetsManualSortPreference);
 667                 final Map<String, Long> params = new HashMap<>();
 668                 params.put("userId", user.getId());
 669                 Mockito.when(dataAccessService.executeNamedQuery("userWidgetManualSortPrfQuery", params, null))
 670                                 .thenReturn(mockEPManualWidgets);
 671                 FieldsValidator expected = new FieldsValidator();
 672                 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
 673                 List<EPWidgetsSortPreference> epWidgetsSortPreferenceList = new ArrayList<>();
 674                 EPWidgetsSortPreference mockEPWidgetsSortPreference = new EPWidgetsSortPreference();
 675                 mockEPWidgetsSortPreference.setRow(2);
 676                 mockEPWidgetsSortPreference.setHeaderText("test");
 677                 mockEPWidgetsSortPreference.setSizeX(2);
 678                 mockEPWidgetsSortPreference.setSizeY(2);
 679                 mockEPWidgetsSortPreference.setWidgetid(2l);
 680                 mockEPWidgetsSortPreference.setWidgetIdentifier("test");
 681                 mockEPWidgetsSortPreference.setCol(2);
 682                 epWidgetsSortPreferenceList.add(mockEPWidgetsSortPreference);
 683                 FieldsValidator actual = epAppCommonServiceImpl.saveWidgetsSortManual(epWidgetsSortPreferenceList, user);
 684                 assertEquals(expected, actual);
 685         }
 686
 687         @Test
 688         public void deleteUserWidgetSortPrefTest() {
 689                 EPUser user = mockUser.mockEPUser();
 690                 List<EPWidgetsManualSortPreference> mockEPManualWidgets = new ArrayList<>();
 691                 EPWidgetsManualSortPreference epWidgetsManualSortPreference = new EPWidgetsManualSortPreference();
 692                 epWidgetsManualSortPreference.setUserId(user.getId());
 693                 epWidgetsManualSortPreference.setWidgetCol(1);
 694                 epWidgetsManualSortPreference.setWidgetHeight(1);
 695                 epWidgetsManualSortPreference.setWidgetId(2l);
 696                 epWidgetsManualSortPreference.setWidgetRow(1);
 697                 epWidgetsManualSortPreference.setWidgetWidth(1);
 698                 mockEPManualWidgets.add(epWidgetsManualSortPreference);
 699                 final Map<String, Long> params = new HashMap<>();
 700                 params.put("userId", user.getId());
 701                 Mockito.when(dataAccessService.executeNamedQuery("userWidgetManualSortPrfQuery", params, null))
 702                                 .thenReturn(mockEPManualWidgets);
 703                 FieldsValidator expected = new FieldsValidator();
 704                 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
 705                 List<EPWidgetsSortPreference> epWidgetsSortPreferenceList = new ArrayList<>();
 706                 EPWidgetsSortPreference mockEPWidgetsSortPreference = new EPWidgetsSortPreference();
 707                 mockEPWidgetsSortPreference.setRow(2);
 708                 mockEPWidgetsSortPreference.setHeaderText("test");
 709                 mockEPWidgetsSortPreference.setSizeX(2);
 710                 mockEPWidgetsSortPreference.setSizeY(2);
 711                 mockEPWidgetsSortPreference.setWidgetid(2l);
 712                 mockEPWidgetsSortPreference.setWidgetIdentifier("test");
 713                 mockEPWidgetsSortPreference.setCol(2);
 714                 epWidgetsSortPreferenceList.add(mockEPWidgetsSortPreference);
 715                 FieldsValidator actual = epAppCommonServiceImpl.deleteUserWidgetSortPref(epWidgetsSortPreferenceList, user);
 716                 assertEquals(expected, actual);
 717         }
 718
 719         @Test
 720         public void saveAppsSortPreferenceForNewUserTest() {
 721                 EPUser user = mockUser.mockEPUser();
 722                 List<EPUserAppsSortPreference> mockEPAppSortPrefList = new ArrayList<>();
 723                 final Map<String, Long> params = new HashMap<>();
 724                 params.put("userId", user.getId());
 725                 Mockito.when(dataAccessService.executeNamedQuery("userAppsSortPreferenceQuery", params, null))
 726                                 .thenReturn(mockEPAppSortPrefList);
 727                 FieldsValidator expected = new FieldsValidator();
 728                 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
 729                 EPAppsSortPreference mockEPAppsSortPreference = new EPAppsSortPreference();
 730                 mockEPAppsSortPreference.setIndex(1);
 731                 mockEPAppsSortPreference.setTitle("Last Used");
 732                 mockEPAppsSortPreference.setValue("L");
 733                 FieldsValidator actual = epAppCommonServiceImpl.saveAppsSortPreference(mockEPAppsSortPreference, user);
 734                 assertEquals(expected, actual);
 735         }
 736
 737         @Test
 738         public void saveAppsSortPreferenceUpdateTest() {
 739                 EPUser user = mockUser.mockEPUser();
 740                 List<EPUserAppsSortPreference> mockEPAppSortPrefList = new ArrayList<>();
 741                 EPUserAppsSortPreference mockEPAppSortPref = new EPUserAppsSortPreference();
 742                 mockEPAppSortPref.setSortPref("L");
 743                 mockEPAppSortPref.setId(2l);
 744                 mockEPAppSortPref.setUserId((int) (long) user.getId());
 745                 mockEPAppSortPrefList.add(mockEPAppSortPref);
 746                 final Map<String, Long> params = new HashMap<>();
 747                 params.put("userId", user.getId());
 748                 Mockito.when(dataAccessService.executeNamedQuery("userAppsSortPreferenceQuery", params, null))
 749                                 .thenReturn(mockEPAppSortPrefList);
 750                 FieldsValidator expected = new FieldsValidator();
 751                 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
 752                 EPAppsSortPreference mockEPAppsSortPreference = new EPAppsSortPreference();
 753                 mockEPAppsSortPreference.setIndex(1);
 754                 mockEPAppsSortPreference.setTitle("Last Used");
 755                 mockEPAppsSortPreference.setValue("L");
 756                 FieldsValidator actual = epAppCommonServiceImpl.saveAppsSortPreference(mockEPAppsSortPreference, user);
 757                 assertEquals(expected, actual);
 758         }
 759
 760         @Test
 761         public void saveAppsSortPreferenceExceptionTest() {
 762                 EPUser user = mockUser.mockEPUser();
 763                 final Map<String, Long> params = new HashMap<>();
 764                 params.put("userId", user.getId());
 765                 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
 766                 FieldsValidator expected = new FieldsValidator();
 767                 expected.setHttpStatusCode(500l);
 768                 //expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
 769                 EPAppsSortPreference mockEPAppsSortPreference = new EPAppsSortPreference();
 770                 mockEPAppsSortPreference.setIndex(1);
 771                 mockEPAppsSortPreference.setTitle("Last Used");
 772                 mockEPAppsSortPreference.setValue("L");
 773                 FieldsValidator actual = epAppCommonServiceImpl.saveAppsSortPreference(mockEPAppsSortPreference, user);
 774                 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
 775         }
 776
 777         @Test
 778         public void getUserAppsSortTypePreferenceTest() {
 779                 EPUser user = mockUser.mockEPUser();
 780                 final Map<String, Long> params = new HashMap<>();
 781                 List<EPUserAppsSortPreference> mockEPAppSortPrefList = new ArrayList<>();
 782                 EPUserAppsSortPreference mockEPAppSortPref = new EPUserAppsSortPreference();
 783                 mockEPAppSortPref.setSortPref("L");
 784                 mockEPAppSortPref.setId(2l);
 785                 mockEPAppSortPref.setUserId((int) (long) user.getId());
 786                 mockEPAppSortPrefList.add(mockEPAppSortPref);
 787                 params.put("userId", user.getId());
 788                 Mockito.when(dataAccessService.executeNamedQuery("userAppsSortPreferenceQuery", params, null))
 789                                 .thenReturn(mockEPAppSortPrefList);
 790                 String actual = epAppCommonServiceImpl.getUserAppsSortTypePreference(user);
 791                 assertEquals(mockEPAppSortPref.getSortPref(), actual);
 792         }
 793
 794         @Test
 795         public void getUserAppsSortTypePreferenceExceptionTest() {
 796                 EPUser user = mockUser.mockEPUser();
 797                 final Map<String, Long> params = new HashMap<>();
 798                 List<EPUserAppsSortPreference> mockEPAppSortPrefList = new ArrayList<>();
 799                 EPUserAppsSortPreference mockEPAppSortPref = new EPUserAppsSortPreference();
 800                 mockEPAppSortPref.setSortPref("L");
 801                 mockEPAppSortPref.setId(2l);
 802                 mockEPAppSortPref.setUserId((int) (long) user.getId());
 803                 mockEPAppSortPrefList.add(mockEPAppSortPref);
 804                 params.put("userId", user.getId());
 805                 Mockito.doThrow(new NullPointerException()).when(dataAccessService)
 806                                 .executeNamedQuery("userAppsSortPreferenceQuery", params, null);
 807                 String actual = epAppCommonServiceImpl.getUserAppsSortTypePreference(user);
 808                 assertNull(actual);
 809         }
 810
 811         @Test
 812         public void deleteUserAppSortManualTest() {
 813                 EPUser user = mockUser.mockEPUser();
 814                 EPApp mockApp = mockApp();
 815                 mockApp.setId(1l);
 816                 final Map<String, Long> params = new HashMap<>();
 817                 List<EPUserAppsManualSortPreference> epManualApps = new ArrayList<EPUserAppsManualSortPreference>();
 818                 EPUserAppsManualSortPreference epManualApp = new EPUserAppsManualSortPreference();
 819                 epManualApp.setAppId(mockApp.getId());
 820                 epManualApp.setAppManualSortOrder(1);
 821                 epManualApp.setId(1l);
 822                 epManualApp.setUserId(user.getId());
 823                 epManualApps.add(epManualApp);
 824                 params.put("userId", user.getId());
 825                 Mockito.when(dataAccessService.executeNamedQuery("userAppsManualSortPrfQuery", params, null)).thenReturn(epManualApps);
 826                 EPDeleteAppsManualSortPref delAppSortManual = new EPDeleteAppsManualSortPref();
 827                 delAppSortManual.setAppId(mockApp.getId());
 828                 delAppSortManual.setPending(false);
 829                 delAppSortManual.setSelect(false);
 830                 FieldsValidator actual = epAppCommonServiceImpl.deleteUserAppSortManual(delAppSortManual, user);
 831                 FieldsValidator expected = new FieldsValidator();
 832                 expected.setHttpStatusCode(200l);
 833                 assertEquals(expected, actual);
 834         }
 835
 836         @Test
 837         public void deleteUserAppSortManualExceptionTest() {
 838                 EPUser user = mockUser.mockEPUser();
 839                 EPApp mockApp = mockApp();
 840                 mockApp.setId(1l);
 841                 final Map<String, Long> params = new HashMap<>();
 842                 List<EPUserAppsManualSortPreference> epManualApps = new ArrayList<EPUserAppsManualSortPreference>();
 843                 EPUserAppsManualSortPreference epManualApp = new EPUserAppsManualSortPreference();
 844                 epManualApp.setAppId(mockApp.getId());
 845                 epManualApp.setAppManualSortOrder(1);
 846                 epManualApp.setId(1l);
 847                 epManualApp.setUserId(user.getId());
 848                 epManualApps.add(epManualApp);
 849                 params.put("userId", user.getId());
 850                 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery("userAppsManualSortPrfQuery", params, null);
 851                 EPDeleteAppsManualSortPref delAppSortManual = new EPDeleteAppsManualSortPref();
 852                 delAppSortManual.setAppId(mockApp.getId());
 853                 delAppSortManual.setPending(false);
 854                 delAppSortManual.setSelect(false);
 855                 FieldsValidator actual = epAppCommonServiceImpl.deleteUserAppSortManual(delAppSortManual, user);
 856                 FieldsValidator expected = new FieldsValidator();
 857                 expected.setHttpStatusCode(500l);
 858                 assertEquals(expected, actual);
 859         }
 860
 861     @SuppressWarnings("unchecked")
 862         @Test
 863         public void getAppDetailByAppNameTest(){
 864                 String appName = "test";
 865                 EPApp expectedResult = mockApp();
 866                 List<EPApp> appList = new ArrayList<>();
 867                 appList.add(expectedResult);
 868                 final Map<String, String> params = new HashMap<String, String>();
 869                 params.put("appName", expectedResult.getName());
 870                 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAppDetailsByAppName", params, null))
 871                                 .thenReturn(appList);
 872                 EPApp actualResult = epAppCommonServiceImpl.getAppDetailByAppName(appName);
 873                 assertEquals(expectedResult, actualResult);
 874         }
 875
 876     @SuppressWarnings("unchecked")
 877         @Test
 878         public void getAppDetailByAppNameExceptionTest(){
 879                 String appName = null;
 880                 EPApp expectedResult = null;
 881                 List<EPApp> appList = new ArrayList<>();
 882                 appList.add(expectedResult);
 883                 final Map<String, String> params = new HashMap<String, String>();
 884                 params.put("appName", null);
 885                 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAppDetailsByAppName", params, null))
 886                                 .thenReturn(appList);
 887                 EPApp actualResult = epAppCommonServiceImpl.getAppDetailByAppName(appName);
 888                 assertEquals(expectedResult, actualResult);
 889         }
 890
 891     @SuppressWarnings("unchecked")
 892         @Test
 893     public void getAppsForSuperAdminAndAccountAdminTest(){
 894         String sql = "SELECT app.APP_ID, app.APP_NAME, app.APP_TYPE FROM FN_APP app "
 895                                 + "where app.ENABLED = 'Y' AND app.app_type = 1";
 896         EPUser user = mockUser.mockEPUser();
 897         List<AppIdAndNameTransportModel> expected = null;
 898         Mockito.when(adminRolesServiceImpl.isSuperAdmin(user)).thenReturn(true);
 899         Mockito.when(adminRolesServiceImpl.isAccountAdmin(user)).thenReturn(true);
 900         List<AppIdAndNameTransportModel> actual = null;
 901         Mockito.when((List<AppIdAndNameTransportModel>) dataAccessService.executeSQLQuery(sql, AppIdAndNameTransportModel.class, null))
 902                                                                                                                                                         .thenReturn(actual);
 903         actual = epAppCommonServiceImpl.getAppsForSuperAdminAndAccountAdmin(user);
 904         assertEquals(expected, actual);
 905     }
 906
 907     @SuppressWarnings("unchecked")
 908         @Test
 909        public void getAppsForSuperAdminAndNotAccountAdminTest(){
 910         String sql = "SELECT app.APP_ID, app.APP_NAME, app.APP_TYPE FROM FN_APP app "
 911                                 + "where app.ENABLED = 'Y' AND app.app_type = 1";
 912         EPUser user = mockUser.mockEPUser();
 913         List<AppIdAndNameTransportModel> expected = new ArrayList<AppIdAndNameTransportModel>();
 914         Mockito.when(adminRolesServiceImpl.isSuperAdmin(user)).thenReturn(false);
 915         Mockito.when(adminRolesServiceImpl.isAccountAdmin(user)).thenReturn(true);
 916         List<AppIdAndNameTransportModel> actual = null;
 917         Mockito.when((List<AppIdAndNameTransportModel>) dataAccessService.executeSQLQuery(sql, AppIdAndNameTransportModel.class, null))
 918                                                                                                                                                         .thenReturn(actual);
 919         actual = epAppCommonServiceImpl.getAppsForSuperAdminAndAccountAdmin(user);
 920         assertEquals(expected, actual);
 921        }
 922
 923     @SuppressWarnings("unchecked")
 924         @Test
 925     public void getAppsForAdminAndAccountAdminTest(){
 926         String sql = "SELECT app.APP_ID, app.APP_NAME, app.APP_TYPE FROM FN_APP app "
 927                                 + "where app.ENABLED = 'Y' AND app.app_type = 1";
 928         EPUser user = mockUser.mockEPUser();
 929         List<AppIdAndNameTransportModel> expected = null;
 930         Mockito.when(adminRolesServiceImpl.isSuperAdmin(user)).thenReturn(true);
 931         List<AppIdAndNameTransportModel> actual = null;
 932         Mockito.when((List<AppIdAndNameTransportModel>) dataAccessService.executeSQLQuery(sql, AppIdAndNameTransportModel.class, null))
 933                                                                                                                                                         .thenReturn(actual);
 934         actual = epAppCommonServiceImpl.getAppsForSuperAdminAndAccountAdmin(user);
 935         assertEquals(expected, actual);
 936     }
 937
 938     @Test
 939     public void getAppsForSuperAdminAndAccountAdminExceptionTest(){
 940         String sql = "SELECT app.APP_ID, app.APP_NAME, app.APP_TYPE FROM FN_APP app "
 941                                 + "where app.ENABLED = 'Y' AND app.app_type = 1";
 942         EPUser user = mockUser.mockEPUser();
 943         List<AppIdAndNameTransportModel> expected = new ArrayList<AppIdAndNameTransportModel>();
 944         Mockito.when(adminRolesServiceImpl.isSuperAdmin(user)).thenReturn(true);
 945         List<AppIdAndNameTransportModel> actual = null;
 946         Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeSQLQuery(sql, AppIdAndNameTransportModel.class, null);
 947         actual = epAppCommonServiceImpl.getAppsForSuperAdminAndAccountAdmin(user);
 948         assertEquals(expected, actual);
 949     }
 950
 951     @Test
 952     public void getDataAccessServiceTest(){
 953         assertEquals(epAppCommonServiceImpl.getDataAccessService(), epAppCommonServiceImpl.getDataAccessService());
 954     }
 955
 956     @SuppressWarnings("unchecked")
 957         @Test
 958     public void getAppsAdminsTest(){
 959         List<AdminUserApplications> expected = new ArrayList<AdminUserApplications>();
 960         List<AdminUserApplications> actual = null;
 961         List<AdminUserApp> list = new ArrayList<AdminUserApp>();
 962         Map<String, String> params = new HashMap<>();
 963         params.put("accountAdminRoleId", ACCOUNT_ADMIN_ROLE_ID);
 964         Mockito.when((List<AdminUserApp>) dataAccessService.executeNamedQuery("getAppsAdmins", params, null)).thenReturn(list);
 965         actual = epAppCommonServiceImpl.getAppsAdmins();
 966         assertEquals(expected, actual);
 967     }
 968
 969     @Test
 970     public void getAppsAdminsExceptionTest(){
 971         List<AdminUserApplications> expected = null;
 972         List<AdminUserApplications> actual = null;
 973         Map<String, String> params = new HashMap<>();
 974         params.put("accountAdminRoleId", ACCOUNT_ADMIN_ROLE_ID);
 975         Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery("getAppsAdmins", params, null);
 976         actual = epAppCommonServiceImpl.getAppsAdmins();
 977         assertEquals(expected, actual);
 978     }
 979
 980         @SuppressWarnings("unchecked")
 981         @Test
 982     public void getAppsAdminsAggregateResultsTest(){
 983         List<AdminUserApplications> expected = new ArrayList<AdminUserApplications>();
 984         AdminUserApp adminUserApp = new AdminUserApp();
 985         AdminUserApplications adminUserApplications = new AdminUserApplications(adminUserApp);
 986         expected.add(adminUserApplications);
 987         List<AdminUserApplications> actual = null;
 988         List<AdminUserApp> list = new ArrayList<AdminUserApp>();
 989         AdminUserApp adminUserApp1 = new AdminUserApp();
 990         list.add(adminUserApp1);
 991         Map<String, String> params = new HashMap<>();
 992         params.put("accountAdminRoleId", ACCOUNT_ADMIN_ROLE_ID);
 993         Mockito.when((List<AdminUserApp>) dataAccessService.executeNamedQuery("getAppsAdmins", params, null)).thenReturn(list);
 994         actual = epAppCommonServiceImpl.getAppsAdmins();
 995         assertEquals(expected.size(), actual.size());
 996     }
 997
 998         @SuppressWarnings("unchecked")
 999         @Test
1000         public void getUserAppsTest(){
1001                 String sql ="";
1002                 EPApp epApp = new EPApp();
1003                 epApp.setOpen(false);
1004                 List<EPApp> expected = new ArrayList<EPApp>();
1005                 List<EPApp> list = new ArrayList<EPApp>();
1006                 EPUser epUser = new EPUser();
1007                 list.add(epApp);
1008                 Mockito.when((List<EPApp>) dataAccessService.executeSQLQuery(sql, EPApp.class, null)).thenReturn(list);
1009                 List<EPApp> actual = epAppCommonServiceImpl.getUserApps(epUser);
1010                 assertEquals(expected.size(), actual.size());
1011         }
1012
1013         @SuppressWarnings("unchecked")
1014         @Test
1015         public void getUserAppsUserGuestTest(){
1016                 String sql ="";
1017                 List<EPApp> expected = new ArrayList<EPApp>();
1018                 List<EPApp> list = new ArrayList<EPApp>();
1019                 EPUser epUser = new EPUser();
1020                 epUser.setGuest(true);
1021                 Mockito.when((List<EPApp>) dataAccessService.executeSQLQuery(sql, EPApp.class, null)).thenReturn(list);
1022                 List<EPApp> actual = epAppCommonServiceImpl.getUserApps(epUser);
1023                 assertEquals(expected.size(), actual.size());
1024         }
1025
1026         @SuppressWarnings("unchecked")
1027         @Test
1028         public void getPersAdminAppsTest(){
1029                 List<EPApp> expected = new ArrayList<EPApp>();
1030                 final Map<String, Long> params = new HashMap<>();
1031                 params.put("userId", (long)123);
1032                 EPUser epUser = new EPUser();
1033                 List<EPApp> list = new ArrayList<EPApp>();
1034                 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getPersAdminApps", params, null)).thenReturn(list);
1035                 List<EPApp> actual = epAppCommonServiceImpl.getPersAdminApps(epUser);
1036                 assertEquals(expected, actual);
1037         }
1038
1039         @SuppressWarnings("unchecked")
1040         @Test
1041         public void getPersUserAppsTest(){
1042                 List<EPApp> expected = new ArrayList<EPApp>();
1043                 EPUser epUser = new EPUser();
1044                 final Map<String, Long> params = new HashMap<>();
1045                 params.put("userId", (long)123);
1046                 List<EPApp> list = new ArrayList<EPApp>();
1047                 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getPersUserApps", params, null)).thenReturn(list);
1048                 List<EPApp> actual = epAppCommonServiceImpl.getPersUserApps(epUser);
1049                 assertEquals(expected, actual);
1050         }
1051
1052         @SuppressWarnings("unchecked")
1053         @Test
1054         public void getUserAppCatalogTest(){
1055                 List<AppCatalogItem> expected = new ArrayList<AppCatalogItem>();
1056                 EPUser epUser = new EPUser();
1057                 final Map<String, Long> params = new HashMap<>();
1058                 params.put("userId", (long)123);
1059                 List<AppCatalogItem> list = new ArrayList<AppCatalogItem>();
1060                 Mockito.when((List<AppCatalogItem>) dataAccessService.executeNamedQuery("getUserAppCatalog", params, null)).thenReturn(list);
1061                 List<AppCatalogItem> actual = epAppCommonServiceImpl.getUserAppCatalog(epUser);
1062                 assertEquals(expected, actual);
1063         }
1064
1065         @SuppressWarnings("unchecked")
1066         @Test
1067         public void getAdminAppCatalogTest(){
1068                 List<AppCatalogItem> expected = new ArrayList<AppCatalogItem>();
1069                 EPUser epUser = new EPUser();
1070                 final Map<String, Long> params = new HashMap<>();
1071                 params.put("userId", (long)123);
1072                 List<AppCatalogItem> list = new ArrayList<AppCatalogItem>();
1073                 Mockito.when((List<AppCatalogItem>) dataAccessService.executeNamedQuery("getAdminAppCatalog", params, null)).thenReturn(list);
1074                 List<AppCatalogItem> actual = epAppCommonServiceImpl.getAdminAppCatalog(epUser);
1075                 assertEquals(expected, actual);
1076         }
1077
1078         @SuppressWarnings("unchecked")
1079         @Test
1080         public void getAppsOrderByNameTest(){
1081                 List<EPApp> expected = new ArrayList<EPApp>();
1082                 EPUser epUser = new EPUser();
1083                 List<EPApp> list = new ArrayList<EPApp>();
1084                 final Map<String, Long> params = new HashMap<>();
1085                 params.put("userId", (long)123);
1086                 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1087                 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getPersAdminAppsOrderByName", params, null)).thenReturn(list);
1088                 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByName(epUser);
1089                 assertEquals(expected, actual);
1090         }
1091
1092         @SuppressWarnings("unchecked")
1093         @Test
1094         public void getAppsOrderByNameNotSuperAdminTest(){
1095                 List<EPApp> expected = new ArrayList<EPApp>();
1096                 EPUser epUser = new EPUser();
1097                 List<EPApp> list = new ArrayList<EPApp>();
1098                 final Map<String, Long> params = new HashMap<>();
1099                 params.put("userId", (long)123);
1100                 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(false);
1101                 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getPersAdminAppsOrderByName", params, null)).thenReturn(list);
1102                 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByName(epUser);
1103                 assertEquals(expected, actual);
1104         }
1105
1106         @Test
1107         public void getAppsOrderByNameExceptionTest(){
1108                 List<EPApp> expected = null;
1109                 EPUser epUser = new EPUser();
1110                 final Map<String, Long> params = new HashMap<>();
1111                 params.put("userId", null);
1112                 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1113                 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
1114                 //Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap())).thenReturn(list);
1115                 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByName(epUser);
1116                 assertEquals(expected, actual);
1117         }
1118
1119         @SuppressWarnings("unchecked")
1120         @Test
1121         public void getAppsOrderByLastUsedTest(){
1122                 List<EPApp> expected = new ArrayList<EPApp>();
1123                 EPUser epUser = new EPUser();
1124                 List<EPApp> list = new ArrayList<EPApp>();
1125                 final Map<String, Long> params = new HashMap<>();
1126                 params.put("userId", (long)123);
1127                 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1128                 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAdminAppsOrderByLastUsed", params, null)).thenReturn(list);
1129                 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByLastUsed(epUser);
1130                 assertEquals(expected, actual);
1131         }
1132
1133         @SuppressWarnings("unchecked")
1134         @Test
1135         public void getAppsOrderByLastUsedNotSuperAdminTest(){
1136                 List<EPApp> expected = new ArrayList<EPApp>();
1137                 EPUser epUser = new EPUser();
1138                 List<EPApp> list = new ArrayList<EPApp>();
1139                 final Map<String, Long> params = new HashMap<>();
1140                 params.put("userId", (long)123);
1141                 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(false);
1142                 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAdminAppsOrderByLastUsed", params, null)).thenReturn(list);
1143                 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByLastUsed(epUser);
1144                 assertEquals(expected, actual);
1145         }
1146
1147         @Test
1148         public void getAppsOrderByLastUsedExceptionTest(){
1149                 List<EPApp> expected = new ArrayList<EPApp>();
1150                 EPUser epUser = new EPUser();
1151                 final Map<String, Long> params = new HashMap<>();
1152                 params.put("userId", null);
1153                 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
1154                 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByLastUsed(epUser);
1155                 assertEquals(expected, actual);
1156         }
1157
1158         @SuppressWarnings("unchecked")
1159         @Test
1160         public void getAppsOrderByMostUsedTest(){
1161                 List<EPApp> expected = new ArrayList<EPApp>();
1162                 EPUser epUser = new EPUser();
1163                 List<EPApp> list = new ArrayList<EPApp>();
1164                 final Map<String, Long> params = new HashMap<>();
1165                 params.put("userId", (long)123);
1166                 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1167                 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAppsOrderByMostUsed", params, null)).thenReturn(list);
1168                 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByMostUsed(epUser);
1169                 assertEquals(expected, actual);
1170         }
1171
1172         @SuppressWarnings("unchecked")
1173         @Test
1174         public void getAppsOrderByMostUsedNotSuperAdminTest(){
1175                 List<EPApp> expected = new ArrayList<EPApp>();
1176                 EPUser epUser = new EPUser();
1177                 List<EPApp> list = new ArrayList<EPApp>();
1178                 final Map<String, Long> params = new HashMap<>();
1179                 params.put("userId", (long)123);
1180                 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(false);
1181                 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAppsOrderByMostUsed", params, null)).thenReturn(list);
1182                 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByMostUsed(epUser);
1183                 assertEquals(expected, actual);
1184         }
1185
1186         @Test
1187         public void getAppsOrderByMostUsedExceptionTest(){
1188                 List<EPApp> expected = new ArrayList<EPApp>();
1189                 EPUser epUser = new EPUser();
1190                 final Map<String, Long> params = new HashMap<>();
1191                 params.put("userId", null);
1192                 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
1193                 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByMostUsed(epUser);
1194                 assertEquals(expected, actual);
1195         }
1196
1197         @SuppressWarnings("unchecked")
1198         @Test
1199         public void getAppsOrderByManualTest(){
1200                 List<EPApp> expected = new ArrayList<EPApp>();
1201                 EPUser epUser = new EPUser();
1202                 List<EPApp> list = new ArrayList<EPApp>();
1203                 final Map<String, Long> params = new HashMap<>();
1204                 params.put("userId", (long)123);
1205                 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1206                 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAdminAppsOrderByManual", params, null)).thenReturn(list);
1207                 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByManual(epUser);
1208                 assertEquals(expected, actual);
1209         }
1210
1211         @SuppressWarnings("unchecked")
1212         @Test
1213         public void getAppsOrderByManualSuperAdminTest(){
1214                 List<EPApp> expected = new ArrayList<EPApp>();
1215                 EPUser epUser = new EPUser();
1216                 List<EPApp> list = new ArrayList<EPApp>();
1217                 final Map<String, Long> params = new HashMap<>();
1218                 params.put("userId", (long)123);
1219                 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(false);
1220                 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAdminAppsOrderByManual", params, null)).thenReturn(list);
1221                 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByManual(epUser);
1222                 assertEquals(expected, actual);
1223         }
1224
1225         @SuppressWarnings("unchecked")
1226         @Test
1227         public void getAppsOrderByManualExceptionTest(){
1228                 List<EPApp> expected = new ArrayList<EPApp>();
1229                 EPUser epUser = new EPUser();
1230                 List<EPApp> list = new ArrayList<EPApp>();
1231                 final Map<String, Long> params = new HashMap<>();
1232                 params.put("userId", null);
1233                 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1234                 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
1235                 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByManual(epUser);
1236                 assertEquals(expected, actual);
1237         }
1238
1239         @SuppressWarnings("deprecation")
1240         @Test
1241         public void getOnboardingAppsTest(){
1242                 List<EPApp> apps = new ArrayList<EPApp>();
1243                 List<OnboardingApp> expected = new ArrayList<OnboardingApp>();
1244                 Mockito.when(dataAccessService.getList(EPApp.class, " where id!=" + ECOMP_APP_ID, null, null)).thenReturn(apps);
1245                 List<OnboardingApp> actual = epAppCommonServiceImpl.getOnboardingApps();
1246                 assertEquals(expected, actual);
1247         }
1248
1249         @Test
1250         public void getEnabledNonOpenOnboardingAppsTest(){
1251                 List<OnboardingApp> expected = new ArrayList<OnboardingApp>();
1252                 List<OnboardingApp> actual = epAppCommonServiceImpl.getEnabledNonOpenOnboardingApps();
1253                 assertEquals(expected, actual);
1254         }
1255
1256         @Test
1257         public void addOnboardingAppTest(){
1258                 FieldsValidator expected = new FieldsValidator();
1259                 expected.setHttpStatusCode(400l);
1260                 EPUser epUser = new EPUser();
1261                 OnboardingApp onboardingApp = new OnboardingApp();
1262                 onboardingApp.setRestrictedApp(true);
1263                 FieldsValidator actual = epAppCommonServiceImpl.addOnboardingApp(onboardingApp, epUser);
1264                 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
1265         }
1266
1267         @Test
1268         public void deleteOnboardingAppTest(){
1269                 FieldsValidator expected = new FieldsValidator();
1270                 expected.setHttpStatusCode(403l);
1271                 EPUser epUser = new EPUser();
1272                 Long appId = (long) 123;
1273                 OnboardingApp onboardingApp = new OnboardingApp();
1274                 onboardingApp.setRestrictedApp(true);
1275                 FieldsValidator actual = epAppCommonServiceImpl.deleteOnboardingApp(epUser, appId);
1276                 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
1277         }
1278
1279         @SuppressWarnings("unchecked")
1280         @Test
1281         public void deleteOnboardingAppSuperAdminTest(){
1282                 FieldsValidator expected = new FieldsValidator();
1283                 expected.setHttpStatusCode(200l);
1284                 EPUser epUser = new EPUser();
1285                 Long appId = (long) 123;
1286                 OnboardingApp onboardingApp = new OnboardingApp();
1287                 onboardingApp.setRestrictedApp(true);
1288                 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1289                 final Map<String, Long> params = new HashMap<>();
1290                 params.put("app_id", (long)123);
1291                 EPUserAppRolesRequest epUserAppRolesRequest = new EPUserAppRolesRequest();
1292                 epUserAppRolesRequest.setUserId((long)123);
1293                 List<EPUserAppRolesRequest> list= new ArrayList<>();
1294                 list.add(epUserAppRolesRequest);
1295                 Mockito.when((List<EPUserAppRolesRequest>) dataAccessService.executeNamedQuery("getRequestIdsForApp", params, null)).thenReturn(list);
1296                 FieldsValidator actual = epAppCommonServiceImpl.deleteOnboardingApp(epUser, appId);
1297                 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
1298         }
1299
1300         @Test(expected=NullPointerException.class)
1301         public void deleteOnboardingAppExceptionTest(){
1302                 FieldsValidator expected = new FieldsValidator();
1303                 expected.setHttpStatusCode(200l);
1304                 EPUser epUser = new EPUser();
1305                 //Long appId = (long) 123;
1306                 List<EPUserAppRolesRequest> epUserAppRolesRequestList= new ArrayList<>();
1307                 OnboardingApp onboardingApp = new OnboardingApp();
1308                 onboardingApp.setRestrictedApp(true);
1309                 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1310                 final Map<String, Long> params = new HashMap<>();
1311                 params.put("app_id", null);
1312                 Mockito.when(dataAccessService.executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap())).thenThrow(nullPointerException);
1313                 Mockito.when(dataAccessService.executeNamedQuery( "getRequestIdsForApp", params, null)).thenReturn(epUserAppRolesRequestList);
1314                 //Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
1315                 FieldsValidator actual = epAppCommonServiceImpl.deleteOnboardingApp(epUser, null);
1316                 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
1317         }
1318
1319         @SuppressWarnings("unchecked")
1320         @Test
1321         public void saveAppsSortManualAppIdNullTest(){
1322                 List<EPUserAppsManualSortPreference> epUserAppsManualSortPreferenceList = new ArrayList<EPUserAppsManualSortPreference>();
1323                 EPAppsManualPreference epAppsManualPreference = new EPAppsManualPreference();
1324                 epAppsManualPreference.setAddRemoveApps(true);
1325                 epAppsManualPreference.setAppid((long)123);
1326                 FieldsValidator expected = new FieldsValidator();
1327                 expected.setHttpStatusCode(200l);
1328                 final Map<String, Long> params = new HashMap<>();
1329                 params.put("userId", (long)123);
1330                 EPUser epUser = new EPUser();
1331                 List<EPAppsManualPreference> list = new ArrayList<EPAppsManualPreference>();
1332                 list.add(epAppsManualPreference);
1333                 Mockito.when(dataAccessService.executeNamedQuery("userAppsManualSortPrfQuery", params, null)).thenReturn(epUserAppsManualSortPreferenceList);
1334                 FieldsValidator actual = epAppCommonServiceImpl.saveAppsSortManual(list, epUser);
1335                 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
1336         }
1337
1338         @Test
1339         public void saveAppsSortManualExceptionTest(){
1340                 FieldsValidator expected = new FieldsValidator();
1341                 expected.setHttpStatusCode(500l);
1342                 final Map<String, Long> params = new HashMap<>();
1343                 params.put("userId", (long)123);
1344                 EPUser epUser = new EPUser();
1345                 List<EPAppsManualPreference> list = new ArrayList<EPAppsManualPreference>();
1346                 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
1347                 FieldsValidator actual = epAppCommonServiceImpl.saveAppsSortManual(list, epUser);
1348                 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
1349         }
1350
1351         @Test
1352         public void getUserProfileForLeftMenuNullListTest(){
1353                 UserRole userRole =new UserRole();
1354                 userRole.setFirstName("test");
1355                 UserRoles  expected = null;
1356                 UserRoles  actual = epAppCommonServiceImpl.getUserProfileForLeftMenu("123");
1357                 assertEquals(expected, actual);
1358         }
1359
1360         @Test
1361         public void getUserProfileForLeftMenuTest(){
1362                 final Map<String, String> params = new HashMap<>();
1363                 params.put("org_user_id", "test");
1364                 UserRole userRole =new UserRole();
1365                 userRole.setFirstName("test");
1366                 UserRoles  expected = null;
1367                 List<UserRole> list = new ArrayList<UserRole>();
1368                 list.add(userRole);
1369                 Mockito.when(dataAccessService.executeNamedQuery( "getUserRolesForLeftMenu", params, null)).thenReturn(list);
1370                 UserRoles  actual = epAppCommonServiceImpl.getUserProfileForLeftMenu("123");
1371                 assertEquals(expected, actual);
1372         }
1373
1374         @Test
1375         public void getUserProfileForRolesLeftMenuNullListTest(){
1376                 UserRoles expected = null;
1377                 List<UserRole> userRoleList = new ArrayList<UserRole>();
1378                 final Map<String, String> params = new HashMap<>();
1379                 params.put("org_user_id", "test");
1380                 Mockito.when(dataAccessService.executeNamedQuery( "getRolesForLeftMenu", params, null)).thenReturn(userRoleList);
1381                 UserRoles  actual = epAppCommonServiceImpl.getUserProfileForRolesLeftMenu("test");
1382                 assertEquals(expected, actual);
1383         }
1384
1385         @Test
1386         public void getUserProfileForRolesLeftMenuTest(){
1387                 UserRole userRole = new UserRole();
1388                 userRole.setRoleId((long)123);
1389                 userRole.setOrgUserId("test");
1390                 userRole.setUser_Id((long)1);
1391                 List<UserRole> userRoleList = new ArrayList<UserRole>();
1392                 userRoleList.add(userRole);
1393                 UserRoles expected = new UserRoles(userRole);
1394                 final Map<String, String> params = new HashMap<>();
1395                 params.put("org_user_id", "test");
1396                 Mockito.when(dataAccessService.executeNamedQuery( "getRolesForLeftMenu", params, null)).thenReturn(userRoleList);
1397                 UserRoles  actual = epAppCommonServiceImpl.getUserProfileForRolesLeftMenu("test");
1398                 assertEquals(expected.getOrgUserId(), actual.getOrgUserId());
1399         }
1400
1401         @Test
1402         public void getUserProfileNormalizedForLeftMenuNullListTest(){
1403                 EPUser epUser = new EPUser();
1404                 List<String> list = new ArrayList<String>();
1405                 list.add("Guest");
1406                 UserRole userRole = new UserRole();
1407                 userRole.setFirstName("GuestT");
1408                 userRole.setLastName("GuestT");
1409                 userRole.setOrgUserId("guestT");
1410                 userRole.setRoleId(1l);
1411                 userRole.setRoleName("Test");
1412                 userRole.setUser_Id(-1l);
1413                 UserRoles expected = new UserRoles(userRole);
1414                 expected.setRoles(list);
1415                 UserRoles actual = epAppCommonServiceImpl.getUserProfileNormalizedForLeftMenu(epUser);
1416                 assertEquals(expected.getRoles(), actual.getRoles());
1417         }
1418
1419         @Test
1420         public void getUserProfileNormalizedForRolesLeftMenuTest(){
1421                 EPUser epUser = new EPUser();
1422                 List<String> list = new ArrayList<String>();
1423                 list.add("Guest");
1424                 UserRole userRole = new UserRole();
1425                 userRole.setFirstName("GuestT");
1426                 userRole.setLastName("GuestT");
1427                 userRole.setOrgUserId("guestT");
1428                 userRole.setRoleId(1l);
1429                 userRole.setRoleName("Test");
1430                 userRole.setUser_Id(-1l);
1431                 UserRoles expected = new UserRoles(userRole);
1432                 expected.setRoles(list);
1433                 UserRoles actual = epAppCommonServiceImpl.getUserProfileNormalizedForRolesLeftMenu(epUser);
1434                 assertEquals(expected.getRoles(), actual.getRoles());
1435         }
1436 }