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