gerrit.onap Code Review - portal.git/blob

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