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) 2017 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  * ECOMP is a trademark and service mark of AT&T Intellectual Property.
  37  */
  38 package org.onap.portalapp.portal.service;
  39
  40 import static org.junit.Assert.assertEquals;
  41 import static org.junit.Assert.assertNull;
  42
  43 import java.util.ArrayList;
  44 import java.util.HashMap;
  45 import java.util.List;
  46 import java.util.Map;
  47
  48 import javax.servlet.http.HttpServletResponse;
  49
  50 import org.hibernate.Session;
  51 import org.hibernate.SessionFactory;
  52 import org.hibernate.Transaction;
  53 import org.hibernate.criterion.Criterion;
  54 import org.hibernate.criterion.Restrictions;
  55 import org.junit.Before;
  56 import org.junit.Test;
  57 import org.junit.runner.RunWith;
  58 import org.mockito.InjectMocks;
  59 import org.mockito.Mock;
  60 import org.mockito.Mockito;
  61 import org.mockito.MockitoAnnotations;
  62 import org.onap.portalapp.portal.core.MockEPUser;
  63 import org.onap.portalapp.portal.domain.AppIdAndNameTransportModel;
  64 import org.onap.portalapp.portal.domain.AppsResponse;
  65 import org.onap.portalapp.portal.domain.EPApp;
  66 import org.onap.portalapp.portal.domain.EPUser;
  67 import org.onap.portalapp.portal.domain.EPUserAppsManualSortPreference;
  68 import org.onap.portalapp.portal.domain.EPUserAppsSortPreference;
  69 import org.onap.portalapp.portal.domain.EPWidgetsManualSortPreference;
  70 import org.onap.portalapp.portal.domain.EcompApp;
  71 import org.onap.portalapp.portal.domain.UserRole;
  72 import org.onap.portalapp.portal.domain.UserRoles;
  73 import org.onap.portalapp.portal.transport.EPAppsSortPreference;
  74 import org.onap.portalapp.portal.transport.EPDeleteAppsManualSortPref;
  75 import org.onap.portalapp.portal.transport.EPWidgetsSortPreference;
  76 import org.onap.portalapp.portal.transport.FieldsValidator;
  77 import org.onap.portalapp.portal.transport.FunctionalMenuItem;
  78 import org.onap.portalapp.portal.transport.LocalRole;
  79 import org.onap.portalapp.portal.transport.OnboardingApp;
  80 import org.onap.portalapp.portal.ueb.EPUebHelper;
  81 import org.onap.portalapp.portal.utils.EPCommonSystemProperties;
  82 import org.onap.portalapp.portal.utils.EcompPortalUtils;
  83 import org.onap.portalapp.portal.utils.PortalConstants;
  84 import org.onap.portalsdk.core.onboarding.util.PortalApiConstants;
  85 import org.onap.portalsdk.core.onboarding.util.PortalApiProperties;
  86 import org.onap.portalsdk.core.service.DataAccessService;
  87 import org.onap.portalsdk.core.service.DataAccessServiceImpl;
  88 import org.onap.portalsdk.core.util.SystemProperties;
  89 import org.powermock.api.mockito.PowerMockito;
  90 import org.powermock.core.classloader.annotations.PowerMockIgnore;
  91 import org.powermock.core.classloader.annotations.PrepareForTest;
  92 import org.powermock.modules.junit4.PowerMockRunner;
  93
  94 import com.att.nsa.apiClient.credentials.ApiCredential;
  95 import com.att.nsa.cambria.client.CambriaClientBuilders;
  96 import com.att.nsa.cambria.client.CambriaIdentityManager;
  97
  98 @RunWith(PowerMockRunner.class)
  99 @PowerMockIgnore({ "org.apache.http.conn.ssl.*", "javax.net.ssl.*", "javax.crypto.*" })
 100 @PrepareForTest({ EcompPortalUtils.class, PortalApiProperties.class, PortalApiConstants.class, SystemProperties.class,
 101                 PortalConstants.class, EPCommonSystemProperties.class })
 102 public class EPAppCommonServiceImplTest {
 103
 104         @Mock
 105         DataAccessService dataAccessService = new DataAccessServiceImpl();
 106
 107         @Mock
 108         AdminRolesServiceImpl adminRolesServiceImpl = new AdminRolesServiceImpl();
 109
 110         @Mock
 111         EPUebHelper epUebHelper;
 112
 113         @Mock
 114         SessionFactory sessionFactory;
 115
 116         @Mock
 117         Session session;
 118
 119         @Mock
 120         Transaction transaction;
 121
 122         @Before
 123         public void setup() {
 124                 MockitoAnnotations.initMocks(this);
 125                 Mockito.when(sessionFactory.openSession()).thenReturn(session);
 126                 Mockito.when(session.beginTransaction()).thenReturn(transaction);
 127         }
 128
 129         MockEPUser mockUser = new MockEPUser();
 130
 131         String ECOMP_APP_ID = "1";
 132         String SUPER_ADMIN_ROLE_ID = "1";
 133         String ACCOUNT_ADMIN_ROLE_ID = "999";
 134         String RESTRICTED_APP_ROLE_ID = "900";
 135
 136         @InjectMocks
 137         EPAppCommonServiceImpl epAppCommonServiceImpl = new EPAppCommonServiceImpl();
 138
 139         public EPApp mockApp() {
 140                 EPApp app = new EPApp();
 141                 app.setName("Test");
 142                 app.setImageUrl("test");
 143                 app.setDescription("test");
 144                 app.setNotes("test");
 145                 app.setUrl("test");
 146                 app.setId((long) 1);
 147                 app.setAppRestEndpoint("test");
 148                 app.setAlternateUrl("test");
 149                 app.setName("test");
 150                 app.setMlAppName("test");
 151                 app.setMlAppAdminId("test");
 152                 app.setUsername("test");
 153                 app.setAppPassword("test");
 154                 app.setOpen(false);
 155                 app.setEnabled(false);
 156                 app.setCentralAuth(true);
 157                 app.setUebKey("test");
 158                 app.setUebSecret("test");
 159                 app.setUebTopicName("test");
 160                 app.setAppType(1);
 161                 return app;
 162         }
 163
 164         @Test
 165         public void getUserAsAdminAppsTest() {
 166                 EPApp mockApp = mockApp();
 167                 EPApp mockApp2 = mockApp();
 168                 mockApp2.setId(2l);
 169                 EPUser user = mockUser.mockEPUser();
 170                 List<EPApp> expected = new ArrayList<>();
 171                 expected.add(mockApp);
 172                 expected.add(mockApp2);
 173                 String sql = "SELECT * FROM FN_APP join FN_USER_ROLE ON FN_USER_ROLE.APP_ID=FN_APP.APP_ID where "
 174                                 + "FN_USER_ROLE.USER_ID=" + user.getId() + " AND FN_USER_ROLE.ROLE_ID=" + ACCOUNT_ADMIN_ROLE_ID
 175                                 + " AND FN_APP.ENABLED = 'Y'";
 176                 Mockito.when(dataAccessService.executeSQLQuery(sql, EPApp.class, null)).thenReturn(expected);
 177                 Mockito.when(adminRolesServiceImpl.isAccountAdmin(user)).thenReturn(true);
 178                 List<EPApp> actual = epAppCommonServiceImpl.getUserAsAdminApps(user);
 179                 assertEquals(expected, actual);
 180         }
 181
 182         @Test
 183         public void getUserAsAdminAppsTestException() {
 184                 EPUser user = mockUser.mockEPUser();
 185                 String sql = "SELECT * FROM FN_APP join FN_USER_ROLE ON FN_USER_ROLE.APP_ID=FN_APP.APP_ID where "
 186                                 + "FN_USER_ROLE.USER_ID=" + user.getId() + " AND FN_USER_ROLE.ROLE_ID=" + ACCOUNT_ADMIN_ROLE_ID
 187                                 + " AND FN_APP.ENABLED = 'Y'";
 188                 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeSQLQuery(sql, EPApp.class, null);
 189                 Mockito.when(adminRolesServiceImpl.isAccountAdmin(user)).thenReturn(true);
 190                 List<EPApp> actual = epAppCommonServiceImpl.getUserAsAdminApps(user);
 191                 assertNull(actual);
 192         }
 193
 194         @Test
 195         public void getUserByOrgUserIdAsAdminAppsTest() {
 196                 EPApp mockApp = mockApp();
 197                 EPApp mockApp2 = mockApp();
 198                 mockApp2.setId(2l);
 199                 EPUser user = mockUser.mockEPUser();
 200                 List<EPApp> expected = new ArrayList<>();
 201                 expected.add(mockApp);
 202                 expected.add(mockApp2);
 203                 String format = "SELECT * FROM FN_APP app INNER JOIN FN_USER_ROLE userrole ON userrole.APP_ID=app.APP_ID "
 204                                 + "INNER JOIN FN_USER user on user.USER_ID = userrole.USER_ID "
 205                                 + "WHERE user.org_user_id = '%s' AND userrole.ROLE_ID=" + ACCOUNT_ADMIN_ROLE_ID
 206                                 + " AND FN_APP.ENABLED = 'Y'";
 207                 String sql = String.format(format, user.getOrgUserId());
 208                 Mockito.when(dataAccessService.executeSQLQuery(sql, EPApp.class, null)).thenReturn(expected);
 209                 List<EPApp> actual = epAppCommonServiceImpl.getUserByOrgUserIdAsAdminApps(user.getOrgUserId());
 210                 assertEquals(expected, actual);
 211         }
 212
 213         @Test
 214         public void getUserByOrgUserIdAsAdminAppsTestException() {
 215                 EPUser user = mockUser.mockEPUser();
 216                 String format = "SELECT * FROM FN_APP app INNER JOIN FN_USER_ROLE userrole ON userrole.APP_ID=app.APP_ID "
 217                                 + "INNER JOIN FN_USER user on user.USER_ID = userrole.USER_ID "
 218                                 + "WHERE user.org_user_id = '%s' AND userrole.ROLE_ID=" + ACCOUNT_ADMIN_ROLE_ID
 219                                 + " AND FN_APP.ENABLED = 'Y'";
 220                 String sql = String.format(format, user.getOrgUserId());
 221                 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeSQLQuery(sql, EPApp.class, null);
 222                 List<EPApp> actual = epAppCommonServiceImpl.getUserByOrgUserIdAsAdminApps(user.getOrgUserId());
 223                 assertNull(actual);
 224         }
 225
 226         @SuppressWarnings("deprecation")
 227         @Test
 228         public void getAppsFullListTest() {
 229                 EPApp mockApp = mockApp();
 230                 EPApp mockApp2 = mockApp();
 231                 mockApp2.setId(2l);
 232                 List<EPApp> expected = new ArrayList<>();
 233                 expected.add(mockApp);
 234                 expected.add(mockApp2);
 235                 Mockito.when(dataAccessService.getList(EPApp.class, null)).thenReturn(expected);
 236                 List<EPApp> actual = epAppCommonServiceImpl.getAppsFullList();
 237                 assertEquals(expected, actual);
 238
 239         }
 240
 241         @Test
 242         public void getEcompAppAppsFullListTest() {
 243                 List<EcompApp> expected = new ArrayList<>();
 244                 List<EcompApp> actual = epAppCommonServiceImpl.getEcompAppAppsFullList();
 245                 assertEquals(expected, actual);
 246         }
 247
 248         @Test
 249         public void transformAppsToEcompAppsTest() {
 250                 EPApp mockApp = mockApp();
 251                 EPApp mockApp2 = mockApp();
 252                 mockApp2.setId(2l);
 253                 List<EPApp> epAppsList = new ArrayList<>();
 254                 epAppsList.add(mockApp);
 255                 epAppsList.add(mockApp2);
 256                 List<EcompApp> expected = new ArrayList<>();
 257                 EcompApp ecompApp = new EcompApp();
 258                 ecompApp.setName("test1");
 259                 EcompApp ecompApp2 = new EcompApp();
 260                 ecompApp2.setName("test2");
 261                 expected.add(ecompApp);
 262                 expected.add(ecompApp2);
 263                 List<EcompApp> actual = epAppCommonServiceImpl.transformAppsToEcompApps(epAppsList);
 264                 assertEquals(expected.size(), actual.size());
 265         }
 266
 267         @SuppressWarnings({ "unchecked", "deprecation" })
 268         @Test
 269         public void getAllAppsForAllTest() {
 270                 EPApp mockApp = mockApp();
 271                 EPApp mockApp2 = mockApp();
 272                 mockApp2.setId(2l);
 273                 List<EPApp> appsList = new ArrayList<>();
 274                 appsList.add(mockApp);
 275                 appsList.add(mockApp2);
 276                 List<AppsResponse> expected = new ArrayList<>();
 277                 AppsResponse appResponse1 = new AppsResponse(mockApp.getId(), mockApp.getName(), mockApp.isRestrictedApp(),
 278                                 mockApp.getEnabled());
 279                 AppsResponse appResponse2 = new AppsResponse(mockApp2.getId(), mockApp2.getName(), mockApp2.isRestrictedApp(),
 280                                 mockApp2.getEnabled());
 281                 expected.add(appResponse1);
 282                 expected.add(appResponse2);
 283                 Mockito.when((List<EPApp>) dataAccessService.getList(EPApp.class, " where id != " + ECOMP_APP_ID, "name", null))
 284                                 .thenReturn(appsList);
 285                 List<AppsResponse> actual = epAppCommonServiceImpl.getAllApps(true);
 286                 assertEquals(expected.size(), actual.size());
 287         }
 288
 289         @SuppressWarnings({ "unchecked", "deprecation" })
 290         @Test
 291         public void getAllAppsIsNotAllTest() {
 292                 EPApp mockApp = mockApp();
 293                 EPApp mockApp2 = mockApp();
 294                 mockApp2.setId(2l);
 295                 List<EPApp> appsList = new ArrayList<>();
 296                 appsList.add(mockApp);
 297                 appsList.add(mockApp2);
 298                 List<AppsResponse> expected = new ArrayList<>();
 299                 AppsResponse appResponse1 = new AppsResponse(mockApp.getId(), mockApp.getName(), mockApp.isRestrictedApp(),
 300                                 mockApp.getEnabled());
 301                 AppsResponse appResponse2 = new AppsResponse(mockApp2.getId(), mockApp2.getName(), mockApp2.isRestrictedApp(),
 302                                 mockApp2.getEnabled());
 303                 expected.add(appResponse1);
 304                 expected.add(appResponse2);
 305                 Mockito.when((List<EPApp>) dataAccessService.getList(EPApp.class,
 306                                 " where ( enabled = 'Y' or id = " + ECOMP_APP_ID + ")", "name", null)).thenReturn(appsList);
 307                 List<AppsResponse> actual = epAppCommonServiceImpl.getAllApps(false);
 308                 assertEquals(expected.size(), actual.size());
 309         }
 310
 311         @Test
 312         public void getAppTest() {
 313                 EPApp expected = mockApp();
 314                 Mockito.when((EPApp) dataAccessService.getDomainObject(EPApp.class, expected.getId(), null))
 315                                 .thenReturn(expected);
 316                 EPApp actual = epAppCommonServiceImpl.getApp(expected.getId());
 317                 assertEquals(expected, actual);
 318         }
 319
 320         @Test
 321         public void getAppExceptionTest() {
 322                 EPApp expected = mockApp();
 323                 Mockito.doThrow(new NullPointerException()).when(dataAccessService).getDomainObject(EPApp.class,
 324                                 expected.getId(), null);
 325                 EPApp actual = epAppCommonServiceImpl.getApp(expected.getId());
 326                 assertNull(actual);
 327         }
 328
 329         @SuppressWarnings("unchecked")
 330         @Test
 331         public void getAppDetailTest() {
 332                 EPApp expected = mockApp();
 333                 List<EPApp> appList = new ArrayList<>();
 334                 appList.add(expected);
 335                 final Map<String, String> params = new HashMap<String, String>();
 336                 params.put("appName", expected.getName());
 337                 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getMyloginAppDetails", params, null))
 338                                 .thenReturn(appList);
 339                 EPApp actual = epAppCommonServiceImpl.getAppDetail(expected.getName());
 340                 assertEquals(expected, actual);
 341         }
 342
 343         @Test
 344         public void getAppDetailExceptionTest() {
 345                 EPApp expected = mockApp();
 346                 List<EPApp> appList = new ArrayList<>();
 347                 appList.add(expected);
 348                 final Map<String, String> params = new HashMap<String, String>();
 349                 params.put("appName", expected.getName());
 350                 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery("getMyloginAppDetails",
 351                                 params, null);
 352                 EPApp actual = epAppCommonServiceImpl.getAppDetail(expected.getName());
 353                 assertNull(actual);
 354         }
 355
 356         @Test
 357         public void getUserProfile() {
 358                 EPUser user = mockUser.mockEPUser();
 359                 final Map<String, String> params = new HashMap<>();
 360                 params.put("org_user_id", user.getOrgUserId());
 361                 List<UserRole> userRoleList = new ArrayList<>();
 362                 UserRole userRole = new UserRole();
 363                 userRole.setFirstName("GuestT");
 364                 userRole.setLastName("GuestT");
 365                 userRole.setOrgUserId("guestT");
 366                 userRole.setRoleId(1l);
 367                 userRole.setRoleName("Test");
 368                 userRole.setUser_Id(-1l);
 369                 userRoleList.add(userRole);
 370                 UserRoles expected = new UserRoles(userRole);
 371                 Mockito.when(dataAccessService.executeNamedQuery("getUserRoles", params, null)).thenReturn(userRoleList);
 372                 UserRoles actual = epAppCommonServiceImpl.getUserProfile(user.getOrgUserId());
 373                 assertEquals(expected.getOrgUserId(), actual.getOrgUserId());
 374         }
 375
 376         @Test
 377         public void getUserProfileNullTest() {
 378                 EPUser user = mockUser.mockEPUser();
 379                 final Map<String, String> params = new HashMap<>();
 380                 params.put("org_user_id", user.getOrgUserId());
 381                 List<UserRole> userRoleList = new ArrayList<>();
 382                 Mockito.when(dataAccessService.executeNamedQuery("getUserRoles", params, null)).thenReturn(userRoleList);
 383                 UserRoles actual = epAppCommonServiceImpl.getUserProfile(user.getOrgUserId());
 384                 assertNull(actual);
 385         }
 386
 387         @Test
 388         public void getUserProfileNormalizedTest() {
 389                 EPUser user = mockUser.mockEPUser();
 390                 user.setGuest(true);
 391                 user.setLoginId("guestT");
 392                 final Map<String, String> params = new HashMap<>();
 393                 params.put("org_user_id", user.getOrgUserId());
 394                 List<UserRole> userRoleList = new ArrayList<>();
 395                 UserRole userRole = new UserRole();
 396                 userRole.setFirstName("GuestT");
 397                 userRole.setLastName("GuestT");
 398                 userRole.setOrgUserId("guestT");
 399                 userRole.setRoleId(1l);
 400                 userRole.setRoleName("Test");
 401                 userRole.setUser_Id(-1l);
 402                 userRoleList.add(userRole);
 403                 UserRoles expected = new UserRoles(userRole);
 404                 Mockito.when(dataAccessService.executeNamedQuery("getUserRoles", params, null)).thenReturn(userRoleList);
 405                 UserRoles actual = epAppCommonServiceImpl.getUserProfileNormalized(user);
 406                 assertEquals(expected.getOrgUserId(), actual.getOrgUserId());
 407         }
 408
 409         @Test
 410         public void getRestrictedAppRolesTest() {
 411                 EPUser user = mockUser.mockEPUser();
 412                 EPApp mockApp = mockApp();
 413                 mockApp.setRestrictedApp(true);
 414                 user.setLoginId("guestT");
 415                 List<LocalRole> expected = new ArrayList<>();
 416                 LocalRole localRole = new LocalRole();
 417                 localRole.setRoleId(1);
 418                 localRole.setRolename("test1");
 419                 expected.add(localRole);
 420                 String sql = "SELECT ROLE_ID, ROLE_NAME from FN_ROLE where UPPER(ACTIVE_YN) = 'Y' AND ROLE_ID = '"
 421                                 + RESTRICTED_APP_ROLE_ID + "'";
 422                 Mockito.when(dataAccessService.executeSQLQuery(sql, LocalRole.class, null)).thenReturn(expected);
 423                 Mockito.when((EPApp) dataAccessService.getDomainObject(EPApp.class, mockApp.getId(), null)).thenReturn(mockApp);
 424                 List<LocalRole> actual = epAppCommonServiceImpl.getAppRoles(mockApp.getId());
 425                 assertEquals(expected, actual);
 426         }
 427
 428         @Test
 429         public void getPoralAppRolesTest() {
 430                 EPUser user = mockUser.mockEPUser();
 431                 EPApp mockApp = mockApp();
 432                 mockApp.setRestrictedApp(false);
 433                 mockApp.setId(1l);
 434                 user.setLoginId("guestT");
 435                 List<LocalRole> expected = new ArrayList<>();
 436                 LocalRole localRole = new LocalRole();
 437                 localRole.setRoleId(1);
 438                 localRole.setRolename("test1");
 439                 expected.add(localRole);
 440                 String sql = "SELECT ROLE_ID, ROLE_NAME from FN_ROLE where UPPER(ACTIVE_YN) = 'Y' AND APP_ID IS NULL";
 441                 Mockito.when(dataAccessService.executeSQLQuery(sql, LocalRole.class, null)).thenReturn(expected);
 442                 Mockito.when((EPApp) dataAccessService.getDomainObject(EPApp.class, mockApp.getId(), null)).thenReturn(mockApp);
 443                 List<LocalRole> actual = epAppCommonServiceImpl.getAppRoles(mockApp.getId());
 444                 assertEquals(expected, actual);
 445         }
 446
 447         @Test
 448         public void getNonPortalAndNonRestrictedAppRolesTest() {
 449                 EPUser user = mockUser.mockEPUser();
 450                 EPApp mockApp = mockApp();
 451                 mockApp.setRestrictedApp(false);
 452                 mockApp.setId(2l);
 453                 user.setLoginId("guestT");
 454                 List<LocalRole> expected = new ArrayList<>();
 455                 LocalRole localRole = new LocalRole();
 456                 localRole.setRoleId(1);
 457                 localRole.setRolename("test1");
 458                 expected.add(localRole);
 459                 String sql = "SELECT ROLE_ID, ROLE_NAME from FN_ROLE where UPPER(ACTIVE_YN) = 'Y' AND APP_ID = '"
 460                                 + mockApp.getId() + "'";
 461                 Mockito.when(dataAccessService.executeSQLQuery(sql, LocalRole.class, null)).thenReturn(expected);
 462                 Mockito.when((EPApp) dataAccessService.getDomainObject(EPApp.class, mockApp.getId(), null)).thenReturn(mockApp);
 463                 List<LocalRole> actual = epAppCommonServiceImpl.getAppRoles(mockApp.getId());
 464                 assertEquals(expected, actual);
 465         }
 466
 467         @Test
 468         public void getAdminAppsTest() {
 469                 EPUser user = mockUser.mockEPUser();
 470                 user.setId(1l);
 471                 List<AppIdAndNameTransportModel> expected = new ArrayList<>();
 472                 AppIdAndNameTransportModel appIdAndNameTransportModel = new AppIdAndNameTransportModel();
 473                 appIdAndNameTransportModel.setId(1l);
 474                 appIdAndNameTransportModel.setName("test1");
 475                 expected.add(appIdAndNameTransportModel);
 476                 Mockito.when(adminRolesServiceImpl.isAccountAdmin(user)).thenReturn(true);
 477                 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 "
 478                                 + "where userrole.USER_ID = %d AND userrole.ROLE_ID=" + ACCOUNT_ADMIN_ROLE_ID
 479                                 + " AND (app.ENABLED = 'Y' OR app.APP_ID=1)";
 480                 String sql = String.format(format, user.getId());
 481                 Mockito.when(dataAccessService.executeSQLQuery(sql, AppIdAndNameTransportModel.class, null))
 482                                 .thenReturn(expected);
 483                 List<AppIdAndNameTransportModel> actual = epAppCommonServiceImpl.getAdminApps(user);
 484                 assertEquals(expected, actual);
 485         }
 486
 487         @Test
 488         public void getAdminAppsExceptionTest() {
 489                 EPUser user = mockUser.mockEPUser();
 490                 user.setId(1l);
 491                 List<AppIdAndNameTransportModel> expected = new ArrayList<>();
 492                 Mockito.when(adminRolesServiceImpl.isAccountAdmin(user)).thenReturn(true);
 493                 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 "
 494                                 + "where userrole.USER_ID = %d AND userrole.ROLE_ID=" + ACCOUNT_ADMIN_ROLE_ID
 495                                 + " AND (app.ENABLED = 'Y' OR app.APP_ID=1)";
 496                 String sql = String.format(format, user.getId());
 497                 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeSQLQuery(sql,
 498                                 AppIdAndNameTransportModel.class, null);
 499                 List<AppIdAndNameTransportModel> actual = epAppCommonServiceImpl.getAdminApps(user);
 500                 assertEquals(expected, actual);
 501         }
 502
 503         @SuppressWarnings("unchecked")
 504         @Test
 505         public void addOnboardingAppUnKnownHostExceptionTest() throws Exception {
 506                 PowerMockito.mockStatic(PortalApiConstants.class);
 507                 PowerMockito.mockStatic(PortalApiProperties.class);
 508                 EPUser user = mockUser.mockEPUser();
 509                 List<EPApp> mockAppList = new ArrayList<>();
 510                 OnboardingApp onboardApp = new OnboardingApp();
 511                 onboardApp.setRestrictedApp(false);
 512                 onboardApp.name = "test1";
 513                 onboardApp.url = "http://test.com";
 514                 onboardApp.isOpen = false;
 515                 onboardApp.isEnabled = true;
 516                 onboardApp.username = "test123";
 517                 onboardApp.appPassword = "test123";
 518                 List<Criterion> restrictionsList = new ArrayList<Criterion>();
 519                 Criterion urlCrit = Restrictions.eq("url", onboardApp.url);
 520                 Criterion nameCrit = Restrictions.eq("name", onboardApp.name);
 521                 Criterion orCrit = Restrictions.or(urlCrit, nameCrit);
 522                 restrictionsList.add(orCrit);
 523                 List<String> uebList = new ArrayList<>();
 524                 uebList.add("localhost");
 525                 com.att.nsa.apiClient.credentials.ApiCredential apiCredential = new ApiCredential(user.getEmail(),
 526                                 "ECOMP Portal Owner");
 527                 CambriaIdentityManager mockIm = Mockito
 528                                 .spy(new CambriaClientBuilders.IdentityManagerBuilder().usingHosts(uebList).build());
 529                 Mockito.doReturn(apiCredential).when(mockIm).createApiKey(user.getEmail(), "ECOMP Portal Owner");
 530                 Mockito.when(PortalApiProperties.getProperty(PortalApiConstants.UEB_URL_LIST)).thenReturn("localhost");
 531                 Mockito.when((List<EPApp>) dataAccessService.getList(EPApp.class, null, restrictionsList, null))
 532                                 .thenReturn(mockAppList);
 533                 FieldsValidator expected = new FieldsValidator();
 534                 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_INTERNAL_SERVER_ERROR));
 535                 FieldsValidator actual = epAppCommonServiceImpl.addOnboardingApp(onboardApp, user);
 536                 assertEquals(expected, actual);
 537         }
 538
 539         @SuppressWarnings("unchecked")
 540         @Test
 541         public void modifyOnboardingAppTest() throws Exception {
 542                 EPUser user = mockUser.mockEPUser();
 543                 EPApp mockApp = mockApp();
 544                 mockApp.setName("test1");
 545                 mockApp.setId(2l);
 546                 mockApp.setUrl("http://test.com");
 547                 mockApp.setUsername("test123");
 548                 mockApp.setAppPassword("test123");
 549                 mockApp.setRestrictedApp(false);
 550                 mockApp.setEnabled(true);
 551                 mockApp.setOpen(false);
 552                 List<EPApp> mockAppList = new ArrayList<>();
 553                 mockAppList.add(mockApp);
 554                 OnboardingApp onboardApp = new OnboardingApp();
 555                 onboardApp.setRestrictedApp(false);
 556                 onboardApp.name = "test1";
 557                 onboardApp.id = 2l;
 558                 onboardApp.url = "http://test.com";
 559                 onboardApp.isOpen = false;
 560                 onboardApp.isEnabled = true;
 561                 onboardApp.thumbnail = "test123imgthumbnail";
 562                 onboardApp.username = "test123";
 563                 onboardApp.appPassword = "test123";
 564                 List<Criterion> restrictionsList1 = new ArrayList<Criterion>();
 565                 Criterion idCrit = Restrictions.eq("id", onboardApp.id);
 566                 Criterion urlCrit = Restrictions.eq("url", onboardApp.url);
 567                 Criterion nameCrit = Restrictions.eq("name", onboardApp.name);
 568                 Criterion orCrit = Restrictions.or(idCrit, urlCrit, nameCrit);
 569                 restrictionsList1.add(orCrit);
 570                 Mockito.when((List<EPApp>) dataAccessService.getList(EPApp.class, null, restrictionsList1, null))
 571                                 .thenReturn(mockAppList);
 572                 Mockito.when((EPApp) session.get(EPApp.class, onboardApp.id)).thenReturn(mockApp);
 573                 String sql = "SELECT m.menu_id, m.column_num, m.text, m.parent_menu_id, m.url, m.active_yn "
 574                                 + "FROM fn_menu_functional m, fn_menu_functional_roles r " + "WHERE m.menu_id = r.menu_id "
 575                                 + " AND r.app_id = '" + onboardApp.id + "' ";
 576                 List<Integer> roles = new ArrayList<>();
 577                 roles.add(1);
 578                 roles.add(2);
 579                 List<FunctionalMenuItem> menuItems = new ArrayList<>();
 580                 FunctionalMenuItem functionalMenuItem = new FunctionalMenuItem();
 581                 functionalMenuItem.setRestrictedApp(false);
 582                 functionalMenuItem.setUrl("http://test1.com");
 583                 functionalMenuItem.setRoles(roles);
 584                 menuItems.add(functionalMenuItem);
 585                 Mockito.when(dataAccessService.executeSQLQuery(sql, FunctionalMenuItem.class, null)).thenReturn(menuItems);
 586                 Mockito.when((FunctionalMenuItem) session.get(FunctionalMenuItem.class, functionalMenuItem.menuId))
 587                                 .thenReturn(functionalMenuItem);
 588                 Mockito.doNothing().when(epUebHelper).addPublisher(mockApp);
 589                 FieldsValidator expected = new FieldsValidator();
 590                 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
 591                 FieldsValidator actual = epAppCommonServiceImpl.modifyOnboardingApp(onboardApp, user);
 592                 assertEquals(expected, actual);
 593         }
 594
 595         @Test
 596         public void saveWidgetsSortManualTest() {
 597                 EPUser user = mockUser.mockEPUser();
 598                 List<EPWidgetsManualSortPreference> mockEPManualWidgets = new ArrayList<>();
 599                 EPWidgetsManualSortPreference epWidgetsManualSortPreference = new EPWidgetsManualSortPreference();
 600                 epWidgetsManualSortPreference.setUserId(user.getId());
 601                 epWidgetsManualSortPreference.setWidgetCol(1);
 602                 epWidgetsManualSortPreference.setWidgetHeight(1);
 603                 epWidgetsManualSortPreference.setWidgetId(1l);
 604                 epWidgetsManualSortPreference.setWidgetRow(1);
 605                 epWidgetsManualSortPreference.setWidgetWidth(1);
 606                 mockEPManualWidgets.add(epWidgetsManualSortPreference);
 607                 final Map<String, Long> params = new HashMap<>();
 608                 params.put("userId", user.getId());
 609                 Mockito.when(dataAccessService.executeNamedQuery("userWidgetManualSortPrfQuery", params, null))
 610                                 .thenReturn(mockEPManualWidgets);
 611                 FieldsValidator expected = new FieldsValidator();
 612                 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
 613                 List<EPWidgetsSortPreference> epWidgetsSortPreferenceList = new ArrayList<>();
 614                 EPWidgetsSortPreference mockEPWidgetsSortPreference = new EPWidgetsSortPreference();
 615                 mockEPWidgetsSortPreference.setRow(2);
 616                 mockEPWidgetsSortPreference.setHeaderText("test");
 617                 mockEPWidgetsSortPreference.setSizeX(2);
 618                 mockEPWidgetsSortPreference.setSizeY(2);
 619                 mockEPWidgetsSortPreference.setWidgetid(2l);
 620                 mockEPWidgetsSortPreference.setWidgetIdentifier("test");
 621                 mockEPWidgetsSortPreference.setCol(2);
 622                 epWidgetsSortPreferenceList.add(mockEPWidgetsSortPreference);
 623                 FieldsValidator actual = epAppCommonServiceImpl.saveWidgetsSortManual(epWidgetsSortPreferenceList, user);
 624                 assertEquals(expected, actual);
 625         }
 626
 627         @Test
 628         public void saveWidgetsSortManualExistingRecordTest() {
 629                 EPUser user = mockUser.mockEPUser();
 630                 List<EPWidgetsManualSortPreference> mockEPManualWidgets = new ArrayList<>();
 631                 EPWidgetsManualSortPreference epWidgetsManualSortPreference = new EPWidgetsManualSortPreference();
 632                 epWidgetsManualSortPreference.setUserId(user.getId());
 633                 epWidgetsManualSortPreference.setWidgetCol(1);
 634                 epWidgetsManualSortPreference.setWidgetHeight(1);
 635                 epWidgetsManualSortPreference.setWidgetId(2l);
 636                 epWidgetsManualSortPreference.setWidgetRow(1);
 637                 epWidgetsManualSortPreference.setWidgetWidth(1);
 638                 mockEPManualWidgets.add(epWidgetsManualSortPreference);
 639                 final Map<String, Long> params = new HashMap<>();
 640                 params.put("userId", user.getId());
 641                 Mockito.when(dataAccessService.executeNamedQuery("userWidgetManualSortPrfQuery", params, null))
 642                                 .thenReturn(mockEPManualWidgets);
 643                 FieldsValidator expected = new FieldsValidator();
 644                 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
 645                 List<EPWidgetsSortPreference> epWidgetsSortPreferenceList = new ArrayList<>();
 646                 EPWidgetsSortPreference mockEPWidgetsSortPreference = new EPWidgetsSortPreference();
 647                 mockEPWidgetsSortPreference.setRow(2);
 648                 mockEPWidgetsSortPreference.setHeaderText("test");
 649                 mockEPWidgetsSortPreference.setSizeX(2);
 650                 mockEPWidgetsSortPreference.setSizeY(2);
 651                 mockEPWidgetsSortPreference.setWidgetid(2l);
 652                 mockEPWidgetsSortPreference.setWidgetIdentifier("test");
 653                 mockEPWidgetsSortPreference.setCol(2);
 654                 epWidgetsSortPreferenceList.add(mockEPWidgetsSortPreference);
 655                 FieldsValidator actual = epAppCommonServiceImpl.saveWidgetsSortManual(epWidgetsSortPreferenceList, user);
 656                 assertEquals(expected, actual);
 657         }
 658
 659         @Test
 660         public void deleteUserWidgetSortPrefTest() {
 661                 EPUser user = mockUser.mockEPUser();
 662                 List<EPWidgetsManualSortPreference> mockEPManualWidgets = new ArrayList<>();
 663                 EPWidgetsManualSortPreference epWidgetsManualSortPreference = new EPWidgetsManualSortPreference();
 664                 epWidgetsManualSortPreference.setUserId(user.getId());
 665                 epWidgetsManualSortPreference.setWidgetCol(1);
 666                 epWidgetsManualSortPreference.setWidgetHeight(1);
 667                 epWidgetsManualSortPreference.setWidgetId(2l);
 668                 epWidgetsManualSortPreference.setWidgetRow(1);
 669                 epWidgetsManualSortPreference.setWidgetWidth(1);
 670                 mockEPManualWidgets.add(epWidgetsManualSortPreference);
 671                 final Map<String, Long> params = new HashMap<>();
 672                 params.put("userId", user.getId());
 673                 Mockito.when(dataAccessService.executeNamedQuery("userWidgetManualSortPrfQuery", params, null))
 674                                 .thenReturn(mockEPManualWidgets);
 675                 FieldsValidator expected = new FieldsValidator();
 676                 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
 677                 List<EPWidgetsSortPreference> epWidgetsSortPreferenceList = new ArrayList<>();
 678                 EPWidgetsSortPreference mockEPWidgetsSortPreference = new EPWidgetsSortPreference();
 679                 mockEPWidgetsSortPreference.setRow(2);
 680                 mockEPWidgetsSortPreference.setHeaderText("test");
 681                 mockEPWidgetsSortPreference.setSizeX(2);
 682                 mockEPWidgetsSortPreference.setSizeY(2);
 683                 mockEPWidgetsSortPreference.setWidgetid(2l);
 684                 mockEPWidgetsSortPreference.setWidgetIdentifier("test");
 685                 mockEPWidgetsSortPreference.setCol(2);
 686                 epWidgetsSortPreferenceList.add(mockEPWidgetsSortPreference);
 687                 FieldsValidator actual = epAppCommonServiceImpl.deleteUserWidgetSortPref(epWidgetsSortPreferenceList, user);
 688                 assertEquals(expected, actual);
 689         }
 690
 691         @Test
 692         public void saveAppsSortPreferenceForNewUserTest() {
 693                 EPUser user = mockUser.mockEPUser();
 694                 List<EPUserAppsSortPreference> mockEPAppSortPrefList = new ArrayList<>();
 695                 final Map<String, Long> params = new HashMap<>();
 696                 params.put("userId", user.getId());
 697                 Mockito.when(dataAccessService.executeNamedQuery("userAppsSortPreferenceQuery", params, null))
 698                                 .thenReturn(mockEPAppSortPrefList);
 699                 FieldsValidator expected = new FieldsValidator();
 700                 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
 701                 EPAppsSortPreference mockEPAppsSortPreference = new EPAppsSortPreference();
 702                 mockEPAppsSortPreference.setIndex(1);
 703                 mockEPAppsSortPreference.setTitle("Last Used");
 704                 mockEPAppsSortPreference.setValue("L");
 705                 FieldsValidator actual = epAppCommonServiceImpl.saveAppsSortPreference(mockEPAppsSortPreference, user);
 706                 assertEquals(expected, actual);
 707         }
 708
 709         @Test
 710         public void saveAppsSortPreferenceUpdateTest() {
 711                 EPUser user = mockUser.mockEPUser();
 712                 List<EPUserAppsSortPreference> mockEPAppSortPrefList = new ArrayList<>();
 713                 EPUserAppsSortPreference mockEPAppSortPref = new EPUserAppsSortPreference();
 714                 mockEPAppSortPref.setSortPref("L");
 715                 mockEPAppSortPref.setId(2l);
 716                 mockEPAppSortPref.setUserId((int) (long) user.getId());
 717                 mockEPAppSortPrefList.add(mockEPAppSortPref);
 718                 final Map<String, Long> params = new HashMap<>();
 719                 params.put("userId", user.getId());
 720                 Mockito.when(dataAccessService.executeNamedQuery("userAppsSortPreferenceQuery", params, null))
 721                                 .thenReturn(mockEPAppSortPrefList);
 722                 FieldsValidator expected = new FieldsValidator();
 723                 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
 724                 EPAppsSortPreference mockEPAppsSortPreference = new EPAppsSortPreference();
 725                 mockEPAppsSortPreference.setIndex(1);
 726                 mockEPAppsSortPreference.setTitle("Last Used");
 727                 mockEPAppsSortPreference.setValue("L");
 728                 FieldsValidator actual = epAppCommonServiceImpl.saveAppsSortPreference(mockEPAppsSortPreference, user);
 729                 assertEquals(expected, actual);
 730         }
 731
 732         @Test
 733         public void getUserAppsSortTypePreferenceTest() {
 734                 EPUser user = mockUser.mockEPUser();
 735                 final Map<String, Long> params = new HashMap<>();
 736                 List<EPUserAppsSortPreference> mockEPAppSortPrefList = new ArrayList<>();
 737                 EPUserAppsSortPreference mockEPAppSortPref = new EPUserAppsSortPreference();
 738                 mockEPAppSortPref.setSortPref("L");
 739                 mockEPAppSortPref.setId(2l);
 740                 mockEPAppSortPref.setUserId((int) (long) user.getId());
 741                 mockEPAppSortPrefList.add(mockEPAppSortPref);
 742                 params.put("userId", user.getId());
 743                 Mockito.when(dataAccessService.executeNamedQuery("userAppsSortPreferenceQuery", params, null))
 744                                 .thenReturn(mockEPAppSortPrefList);
 745                 String actual = epAppCommonServiceImpl.getUserAppsSortTypePreference(user);
 746                 assertEquals(mockEPAppSortPref.getSortPref(), actual);
 747         }
 748
 749         @Test
 750         public void getUserAppsSortTypePreferenceExceptionTest() {
 751                 EPUser user = mockUser.mockEPUser();
 752                 final Map<String, Long> params = new HashMap<>();
 753                 List<EPUserAppsSortPreference> mockEPAppSortPrefList = new ArrayList<>();
 754                 EPUserAppsSortPreference mockEPAppSortPref = new EPUserAppsSortPreference();
 755                 mockEPAppSortPref.setSortPref("L");
 756                 mockEPAppSortPref.setId(2l);
 757                 mockEPAppSortPref.setUserId((int) (long) user.getId());
 758                 mockEPAppSortPrefList.add(mockEPAppSortPref);
 759                 params.put("userId", user.getId());
 760                 Mockito.doThrow(new NullPointerException()).when(dataAccessService)
 761                                 .executeNamedQuery("userAppsSortPreferenceQuery", params, null);
 762                 String actual = epAppCommonServiceImpl.getUserAppsSortTypePreference(user);
 763                 assertNull(actual);
 764         }
 765
 766         @Test
 767         public void deleteUserAppSortManualTest() {
 768                 EPUser user = mockUser.mockEPUser();
 769                 EPApp mockApp = mockApp();
 770                 mockApp.setId(1l);
 771                 final Map<String, Long> params = new HashMap<>();
 772                 List<EPUserAppsManualSortPreference> epManualApps = new ArrayList<EPUserAppsManualSortPreference>();
 773                 EPUserAppsManualSortPreference epManualApp = new EPUserAppsManualSortPreference();
 774                 epManualApp.setAppId(mockApp.getId());
 775                 epManualApp.setAppManualSortOrder(1);
 776                 epManualApp.setId(1l);
 777                 epManualApp.setUserId(user.getId());
 778                 epManualApps.add(epManualApp);
 779                 params.put("userId", user.getId());
 780                 Mockito.when(dataAccessService.executeNamedQuery("userAppsManualSortPrfQuery", params, null)).thenReturn(epManualApps);
 781                 EPDeleteAppsManualSortPref delAppSortManual = new EPDeleteAppsManualSortPref();
 782                 delAppSortManual.setAppId(mockApp.getId());
 783                 delAppSortManual.setPending(false);
 784                 delAppSortManual.setSelect(false);
 785                 FieldsValidator actual = epAppCommonServiceImpl.deleteUserAppSortManual(delAppSortManual, user);
 786                 FieldsValidator expected = new FieldsValidator();
 787                 expected.setHttpStatusCode(200l);
 788                 assertEquals(expected, actual);
 789         }
 790
 791         @Test
 792         public void deleteUserAppSortManualExceptionTest() {
 793                 EPUser user = mockUser.mockEPUser();
 794                 EPApp mockApp = mockApp();
 795                 mockApp.setId(1l);
 796                 final Map<String, Long> params = new HashMap<>();
 797                 List<EPUserAppsManualSortPreference> epManualApps = new ArrayList<EPUserAppsManualSortPreference>();
 798                 EPUserAppsManualSortPreference epManualApp = new EPUserAppsManualSortPreference();
 799                 epManualApp.setAppId(mockApp.getId());
 800                 epManualApp.setAppManualSortOrder(1);
 801                 epManualApp.setId(1l);
 802                 epManualApp.setUserId(user.getId());
 803                 epManualApps.add(epManualApp);
 804                 params.put("userId", user.getId());
 805                 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery("userAppsManualSortPrfQuery", params, null);
 806                 EPDeleteAppsManualSortPref delAppSortManual = new EPDeleteAppsManualSortPref();
 807                 delAppSortManual.setAppId(mockApp.getId());
 808                 delAppSortManual.setPending(false);
 809                 delAppSortManual.setSelect(false);
 810                 FieldsValidator actual = epAppCommonServiceImpl.deleteUserAppSortManual(delAppSortManual, user);
 811                 FieldsValidator expected = new FieldsValidator();
 812                 expected.setHttpStatusCode(500l);
 813                 assertEquals(expected, actual);
 814         }
 815 }