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