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.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;
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 SessionFactory sessionFactory;
117 Transaction transaction;
120 public void setup() {
121 MockitoAnnotations.initMocks(this);
122 Mockito.when(sessionFactory.openSession()).thenReturn(session);
123 Mockito.when(session.beginTransaction()).thenReturn(transaction);
126 MockEPUser mockUser = new MockEPUser();
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";
134 EPAppCommonServiceImpl epAppCommonServiceImpl = new EPAppCommonServiceImpl();
136 public EPApp mockApp() {
137 EPApp app = new EPApp();
139 app.setImageUrl("test");
140 app.setDescription("test");
141 app.setNotes("test");
144 app.setAppRestEndpoint("test");
145 app.setAlternateUrl("test");
147 app.setMlAppName("test");
148 app.setMlAppAdminId("test");
149 app.setUsername("test");
150 app.setAppPassword("test");
152 app.setEnabled(false);
153 app.setCentralAuth(true);
154 app.setUebKey("test");
155 app.setUebSecret("test");
156 app.setUebTopicName("test");
162 public void getUserAsAdminAppsTest() {
163 EPApp mockApp = mockApp();
164 EPApp mockApp2 = mockApp();
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);
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);
192 public void getUserByOrgUserIdAsAdminAppsTest() {
193 EPApp mockApp = mockApp();
194 EPApp mockApp2 = mockApp();
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);
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());
223 @SuppressWarnings("deprecation")
225 public void getAppsFullListTest() {
226 EPApp mockApp = mockApp();
227 EPApp mockApp2 = mockApp();
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);
239 public void getEcompAppAppsFullListTest() {
240 List<EcompApp> expected = new ArrayList<>();
241 List<EcompApp> actual = epAppCommonServiceImpl.getEcompAppAppsFullList();
242 assertEquals(expected, actual);
246 public void transformAppsToEcompAppsTest() {
247 EPApp mockApp = mockApp();
248 EPApp mockApp2 = mockApp();
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());
264 @SuppressWarnings({ "unchecked", "deprecation" })
266 public void getAllAppsForAllTest() {
267 EPApp mockApp = mockApp();
268 EPApp mockApp2 = mockApp();
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());
286 @SuppressWarnings({ "unchecked", "deprecation" })
288 public void getAllAppsIsNotAllTest() {
289 EPApp mockApp = mockApp();
290 EPApp mockApp2 = mockApp();
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());
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);
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());
326 @SuppressWarnings("unchecked")
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);
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",
349 EPApp actual = epAppCommonServiceImpl.getAppDetail(expected.getName());
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());
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());
385 public void getUserProfileNormalizedTest() {
386 EPUser user = mockUser.mockEPUser();
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());
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);
426 public void getPoralAppRolesTest() {
427 EPUser user = mockUser.mockEPUser();
428 EPApp mockApp = mockApp();
429 mockApp.setRestrictedApp(false);
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);
445 public void getNonPortalAndNonRestrictedAppRolesTest() {
446 EPUser user = mockUser.mockEPUser();
447 EPApp mockApp = mockApp();
448 mockApp.setRestrictedApp(false);
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);
465 public void getAdminAppsTest() {
466 EPUser user = mockUser.mockEPUser();
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);
485 public void getAdminAppsExceptionTest() {
486 EPUser user = mockUser.mockEPUser();
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);
501 @SuppressWarnings("unchecked")
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);
537 @SuppressWarnings("unchecked")
539 public void modifyOnboardingAppTest() throws Exception {
540 EPUser user = mockUser.mockEPUser();
541 EPApp mockApp = mockApp();
542 mockApp.setName("test1");
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";
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<>();
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);
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);
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);
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);
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);
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);
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);
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);
764 public void deleteUserAppSortManualTest() {
765 EPUser user = mockUser.mockEPUser();
766 EPApp mockApp = mockApp();
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);
789 public void deleteUserAppSortManualExceptionTest() {
790 EPUser user = mockUser.mockEPUser();
791 EPApp mockApp = mockApp();
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);