2 * ============LICENSE_START==========================================
4 * ===================================================================
5 * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
6 * ===================================================================
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
13 * http://www.apache.org/licenses/LICENSE-2.0
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.
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
26 * https://creativecommons.org/licenses/by/4.0/
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.
34 * ============LICENSE_END============================================
38 package org.onap.portalapp.portal.service;
40 import static org.junit.Assert.assertEquals;
41 import static org.junit.Assert.assertNull;
43 import java.util.ArrayList;
44 import java.util.HashMap;
45 import java.util.List;
48 import javax.servlet.http.HttpServletResponse;
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;
94 import com.att.nsa.apiClient.credentials.ApiCredential;
95 import com.att.nsa.cambria.client.CambriaClientBuilders;
96 import com.att.nsa.cambria.client.CambriaIdentityManager;
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 {
105 DataAccessService dataAccessService = new DataAccessServiceImpl();
108 AdminRolesServiceImpl adminRolesServiceImpl = new AdminRolesServiceImpl();
111 EPUebHelper epUebHelper;
114 SessionFactory sessionFactory;
120 Transaction transaction;
123 public void setup() {
124 MockitoAnnotations.initMocks(this);
125 Mockito.when(sessionFactory.openSession()).thenReturn(session);
126 Mockito.when(session.beginTransaction()).thenReturn(transaction);
129 MockEPUser mockUser = new MockEPUser();
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";
137 EPAppCommonServiceImpl epAppCommonServiceImpl = new EPAppCommonServiceImpl();
139 public EPApp mockApp() {
140 EPApp app = new EPApp();
142 app.setImageUrl("test");
143 app.setDescription("test");
144 app.setNotes("test");
147 app.setAppRestEndpoint("test");
148 app.setAlternateUrl("test");
150 app.setMlAppName("test");
151 app.setMlAppAdminId("test");
152 app.setUsername("test");
153 app.setAppPassword("test");
155 app.setEnabled(false);
156 app.setCentralAuth(true);
157 app.setUebKey("test");
158 app.setUebSecret("test");
159 app.setUebTopicName("test");
165 public void getUserAsAdminAppsTest() {
166 EPApp mockApp = mockApp();
167 EPApp mockApp2 = mockApp();
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);
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);
195 public void getUserByOrgUserIdAsAdminAppsTest() {
196 EPApp mockApp = mockApp();
197 EPApp mockApp2 = mockApp();
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);
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());
226 @SuppressWarnings("deprecation")
228 public void getAppsFullListTest() {
229 EPApp mockApp = mockApp();
230 EPApp mockApp2 = mockApp();
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);
242 public void getEcompAppAppsFullListTest() {
243 List<EcompApp> expected = new ArrayList<>();
244 List<EcompApp> actual = epAppCommonServiceImpl.getEcompAppAppsFullList();
245 assertEquals(expected, actual);
249 public void transformAppsToEcompAppsTest() {
250 EPApp mockApp = mockApp();
251 EPApp mockApp2 = mockApp();
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());
267 @SuppressWarnings({ "unchecked", "deprecation" })
269 public void getAllAppsForAllTest() {
270 EPApp mockApp = mockApp();
271 EPApp mockApp2 = mockApp();
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());
289 @SuppressWarnings({ "unchecked", "deprecation" })
291 public void getAllAppsIsNotAllTest() {
292 EPApp mockApp = mockApp();
293 EPApp mockApp2 = mockApp();
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());
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);
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());
329 @SuppressWarnings("unchecked")
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);
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",
352 EPApp actual = epAppCommonServiceImpl.getAppDetail(expected.getName());
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());
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());
388 public void getUserProfileNormalizedTest() {
389 EPUser user = mockUser.mockEPUser();
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());
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);
429 public void getPoralAppRolesTest() {
430 EPUser user = mockUser.mockEPUser();
431 EPApp mockApp = mockApp();
432 mockApp.setRestrictedApp(false);
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);
448 public void getNonPortalAndNonRestrictedAppRolesTest() {
449 EPUser user = mockUser.mockEPUser();
450 EPApp mockApp = mockApp();
451 mockApp.setRestrictedApp(false);
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);
468 public void getAdminAppsTest() {
469 EPUser user = mockUser.mockEPUser();
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);
488 public void getAdminAppsExceptionTest() {
489 EPUser user = mockUser.mockEPUser();
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);
503 @SuppressWarnings("unchecked")
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);
539 @SuppressWarnings("unchecked")
541 public void modifyOnboardingAppTest() throws Exception {
542 EPUser user = mockUser.mockEPUser();
543 EPApp mockApp = mockApp();
544 mockApp.setName("test1");
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";
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<>();
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);
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);
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);
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);
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);
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);
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);
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);
767 public void deleteUserAppSortManualTest() {
768 EPUser user = mockUser.mockEPUser();
769 EPApp mockApp = mockApp();
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);
792 public void deleteUserAppSortManualExceptionTest() {
793 EPUser user = mockUser.mockEPUser();
794 EPApp mockApp = mockApp();
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);