2 * ============LICENSE_START==========================================
4 * ===================================================================
5 * Copyright (C) 2018 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.Matchers;
61 import org.mockito.Mock;
62 import org.mockito.Mockito;
63 import org.mockito.MockitoAnnotations;
64 import org.onap.portalapp.portal.core.MockEPUser;
65 import org.onap.portalapp.portal.domain.AdminUserApp;
66 import org.onap.portalapp.portal.domain.AdminUserApplications;
67 import org.onap.portalapp.portal.domain.AppIdAndNameTransportModel;
68 import org.onap.portalapp.portal.domain.AppsResponse;
69 import org.onap.portalapp.portal.domain.EPApp;
70 import org.onap.portalapp.portal.domain.EPUser;
71 import org.onap.portalapp.portal.domain.EPUserAppRolesRequest;
72 import org.onap.portalapp.portal.domain.EPUserAppsManualSortPreference;
73 import org.onap.portalapp.portal.domain.EPUserAppsSortPreference;
74 import org.onap.portalapp.portal.domain.EPWidgetsManualSortPreference;
75 import org.onap.portalapp.portal.domain.EcompApp;
76 import org.onap.portalapp.portal.domain.UserRole;
77 import org.onap.portalapp.portal.domain.UserRoles;
78 import org.onap.portalapp.portal.ecomp.model.AppCatalogItem;
79 import org.onap.portalapp.portal.transport.EPAppsManualPreference;
80 import org.onap.portalapp.portal.transport.EPAppsSortPreference;
81 import org.onap.portalapp.portal.transport.EPDeleteAppsManualSortPref;
82 import org.onap.portalapp.portal.transport.EPWidgetsSortPreference;
83 import org.onap.portalapp.portal.transport.FieldsValidator;
84 import org.onap.portalapp.portal.transport.FunctionalMenuItem;
85 import org.onap.portalapp.portal.transport.LocalRole;
86 import org.onap.portalapp.portal.transport.OnboardingApp;
87 import org.onap.portalapp.portal.utils.EPCommonSystemProperties;
88 import org.onap.portalapp.portal.utils.EcompPortalUtils;
89 import org.onap.portalapp.portal.utils.PortalConstants;
90 import org.onap.portalsdk.core.onboarding.util.PortalApiConstants;
91 import org.onap.portalsdk.core.onboarding.util.PortalApiProperties;
92 import org.onap.portalsdk.core.service.DataAccessService;
93 import org.onap.portalsdk.core.service.DataAccessServiceImpl;
94 import org.onap.portalsdk.core.util.SystemProperties;
95 import org.powermock.api.mockito.PowerMockito;
96 import org.powermock.core.classloader.annotations.PowerMockIgnore;
97 import org.powermock.core.classloader.annotations.PrepareForTest;
98 import org.powermock.modules.junit4.PowerMockRunner;
100 import com.att.nsa.apiClient.credentials.ApiCredential;
101 import com.att.nsa.cambria.client.CambriaClientBuilders;
102 import com.att.nsa.cambria.client.CambriaIdentityManager;
104 @RunWith(PowerMockRunner.class)
105 @PowerMockIgnore({ "org.apache.http.conn.ssl.*", "javax.net.ssl.*", "javax.crypto.*" })
106 @PrepareForTest({ EcompPortalUtils.class, PortalApiProperties.class, PortalApiConstants.class, SystemProperties.class,
107 PortalConstants.class, EPCommonSystemProperties.class })
108 public class EPAppCommonServiceImplTest {
111 DataAccessService dataAccessService = new DataAccessServiceImpl();
114 AdminRolesServiceImpl adminRolesServiceImpl = new AdminRolesServiceImpl();
117 EPAppServiceImpl epAppServiceImpl = new EPAppServiceImpl();*/
120 SessionFactory sessionFactory;
126 Transaction transaction;
128 NullPointerException nullPointerException = new NullPointerException();
131 public void setup() {
132 MockitoAnnotations.initMocks(this);
133 Mockito.when(sessionFactory.openSession()).thenReturn(session);
134 Mockito.when(session.beginTransaction()).thenReturn(transaction);
137 MockEPUser mockUser = new MockEPUser();
139 String ECOMP_APP_ID = "1";
140 String SUPER_ADMIN_ROLE_ID = "1";
141 String ACCOUNT_ADMIN_ROLE_ID = "999";
142 String RESTRICTED_APP_ROLE_ID = "900";
145 EPAppCommonServiceImpl epAppCommonServiceImpl = new EPAppCommonServiceImpl();
147 public EPApp mockApp() {
148 EPApp app = new EPApp();
150 app.setImageUrl("test");
151 app.setDescription("test");
152 app.setNotes("test");
155 app.setAppRestEndpoint("test");
156 app.setAlternateUrl("test");
158 app.setMlAppName("test");
159 app.setMlAppAdminId("test");
160 app.setUsername("test");
161 app.setAppPassword("test");
163 app.setEnabled(false);
164 app.setCentralAuth(true);
165 app.setUebKey("test");
166 app.setUebSecret("test");
167 app.setUebTopicName("test");
173 public void getUserAsAdminAppsTest() {
174 EPApp mockApp = mockApp();
175 EPApp mockApp2 = mockApp();
177 EPUser user = mockUser.mockEPUser();
178 List<EPApp> expected = new ArrayList<>();
179 expected.add(mockApp);
180 expected.add(mockApp2);
181 String sql = "SELECT * FROM FN_APP join FN_USER_ROLE ON FN_USER_ROLE.APP_ID=FN_APP.APP_ID where "
182 + "FN_USER_ROLE.USER_ID=" + user.getId() + " AND FN_USER_ROLE.ROLE_ID=" + ACCOUNT_ADMIN_ROLE_ID
183 + " AND FN_APP.ENABLED = 'Y'";
184 Mockito.when(dataAccessService.executeSQLQuery(sql, EPApp.class, null)).thenReturn(expected);
185 Mockito.when(adminRolesServiceImpl.isAccountAdmin(user)).thenReturn(true);
186 List<EPApp> actual = epAppCommonServiceImpl.getUserAsAdminApps(user);
187 assertEquals(expected, actual);
191 public void getUserAsAdminAppsTestException() {
192 List<EPApp> expected = new ArrayList<>();
193 EPUser user = mockUser.mockEPUser();
194 String sql = "SELECT * FROM FN_APP join FN_USER_ROLE ON FN_USER_ROLE.APP_ID=FN_APP.APP_ID where "
195 + "FN_USER_ROLE.USER_ID=" + user.getId() + " AND FN_USER_ROLE.ROLE_ID=" + ACCOUNT_ADMIN_ROLE_ID
196 + " AND FN_APP.ENABLED = 'Y'";
197 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeSQLQuery(sql, EPApp.class, null);
198 Mockito.when(adminRolesServiceImpl.isAccountAdmin(user)).thenReturn(false);
199 List<EPApp> actual = epAppCommonServiceImpl.getUserAsAdminApps(user);
200 assertEquals(expected, actual);
204 public void getUserByOrgUserIdAsAdminAppsTest() {
205 EPApp mockApp = mockApp();
206 EPApp mockApp2 = mockApp();
208 EPUser user = mockUser.mockEPUser();
209 List<EPApp> expected = new ArrayList<>();
210 expected.add(mockApp);
211 expected.add(mockApp2);
212 String format = "SELECT * FROM FN_APP app INNER JOIN FN_USER_ROLE userrole ON userrole.APP_ID=app.APP_ID "
213 + "INNER JOIN FN_USER user on user.USER_ID = userrole.USER_ID "
214 + "WHERE user.org_user_id = '%s' AND userrole.ROLE_ID=" + ACCOUNT_ADMIN_ROLE_ID
215 + " AND FN_APP.ENABLED = 'Y'";
216 String sql = String.format(format, user.getOrgUserId());
217 Mockito.when(dataAccessService.executeSQLQuery(sql, EPApp.class, null)).thenReturn(expected);
218 List<EPApp> actual = epAppCommonServiceImpl.getUserByOrgUserIdAsAdminApps(user.getOrgUserId());
219 assertEquals(expected, actual);
223 public void getUserByOrgUserIdAsAdminAppsTest1() {
224 EPApp mockApp = mockApp();
225 EPApp mockApp2 = mockApp();
227 EPUser user = mockUser.mockEPUser();
228 List<EPApp> expected = new ArrayList<>();
229 expected.add(mockApp);
230 expected.add(mockApp2);
231 String format = "SELECT * FROM FN_APP app INNER JOIN FN_USER_ROLE userrole ON userrole.APP_ID=app.APP_ID "
232 + "INNER JOIN FN_USER user on user.USER_ID = userrole.USER_ID "
233 + "WHERE user.org_user_id = '%s' AND userrole.ROLE_ID=" + ACCOUNT_ADMIN_ROLE_ID
234 + " AND FN_APP.ENABLED = 'Y'";
235 String sql = String.format(format, user.getOrgUserId());
236 Mockito.when(dataAccessService.executeSQLQuery(sql, EPApp.class, null)).thenReturn(expected);
237 List<EPApp> actual = epAppCommonServiceImpl.getUserByOrgUserIdAsAdminApps(user.getOrgUserId());
238 assertEquals(expected, actual);
242 public void getUserByOrgUserIdAsAdminAppsTestException() {
243 EPUser user = mockUser.mockEPUser();
244 String format = "SELECT * FROM FN_APP app INNER JOIN FN_USER_ROLE userrole ON userrole.APP_ID=app.APP_ID "
245 + "INNER JOIN FN_USER user on user.USER_ID = userrole.USER_ID "
246 + "WHERE user.org_user_id = '%s' AND userrole.ROLE_ID=" + ACCOUNT_ADMIN_ROLE_ID
247 + " AND FN_APP.ENABLED = 'Y'";
248 String sql = String.format(format, user.getOrgUserId());
249 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeSQLQuery(sql, EPApp.class, null);
250 List<EPApp> actual = epAppCommonServiceImpl.getUserByOrgUserIdAsAdminApps(user.getOrgUserId());
254 @SuppressWarnings("deprecation")
256 public void getAppsFullListTest() {
257 EPApp mockApp = mockApp();
258 EPApp mockApp2 = mockApp();
260 List<EPApp> expected = new ArrayList<>();
261 expected.add(mockApp);
262 expected.add(mockApp2);
263 Mockito.when(dataAccessService.getList(EPApp.class, null)).thenReturn(expected);
264 List<EPApp> actual = epAppCommonServiceImpl.getAppsFullList();
265 assertEquals(expected, actual);
270 public void getEcompAppAppsFullListTest() {
271 List<EcompApp> expected = new ArrayList<>();
272 List<EcompApp> actual = epAppCommonServiceImpl.getEcompAppAppsFullList();
273 assertEquals(expected, actual);
277 public void transformAppsToEcompAppsTest() {
278 EPApp mockApp = mockApp();
279 EPApp mockApp2 = mockApp();
281 List<EPApp> epAppsList = new ArrayList<>();
282 epAppsList.add(mockApp);
283 epAppsList.add(mockApp2);
284 List<EcompApp> expected = new ArrayList<>();
285 EcompApp ecompApp = new EcompApp();
286 ecompApp.setName("test1");
287 EcompApp ecompApp2 = new EcompApp();
288 ecompApp2.setName("test2");
289 expected.add(ecompApp);
290 expected.add(ecompApp2);
291 List<EcompApp> actual = epAppCommonServiceImpl.transformAppsToEcompApps(epAppsList);
292 assertEquals(expected.size(), actual.size());
295 @SuppressWarnings({ "unchecked", "deprecation" })
297 public void getAllAppsForAllTest() {
298 EPApp mockApp = mockApp();
299 EPApp mockApp2 = mockApp();
301 List<EPApp> appsList = new ArrayList<>();
302 appsList.add(mockApp);
303 appsList.add(mockApp2);
304 List<AppsResponse> expected = new ArrayList<>();
305 AppsResponse appResponse1 = new AppsResponse(mockApp.getId(), mockApp.getName(), mockApp.isRestrictedApp(),
306 mockApp.getEnabled());
307 AppsResponse appResponse2 = new AppsResponse(mockApp2.getId(), mockApp2.getName(), mockApp2.isRestrictedApp(),
308 mockApp2.getEnabled());
309 expected.add(appResponse1);
310 expected.add(appResponse2);
311 Mockito.when((List<EPApp>) dataAccessService.getList(EPApp.class, " where id != " + ECOMP_APP_ID, "name", null))
312 .thenReturn(appsList);
313 List<AppsResponse> actual = epAppCommonServiceImpl.getAllApps(true);
314 assertEquals(expected.size(), actual.size());
317 @SuppressWarnings({ "unchecked", "deprecation" })
319 public void getAllAppsIsNotAllTest() {
320 EPApp mockApp = mockApp();
321 EPApp mockApp2 = mockApp();
323 List<EPApp> appsList = new ArrayList<>();
324 appsList.add(mockApp);
325 appsList.add(mockApp2);
326 List<AppsResponse> expected = new ArrayList<>();
327 AppsResponse appResponse1 = new AppsResponse(mockApp.getId(), mockApp.getName(), mockApp.isRestrictedApp(),
328 mockApp.getEnabled());
329 AppsResponse appResponse2 = new AppsResponse(mockApp2.getId(), mockApp2.getName(), mockApp2.isRestrictedApp(),
330 mockApp2.getEnabled());
331 expected.add(appResponse1);
332 expected.add(appResponse2);
333 Mockito.when((List<EPApp>) dataAccessService.getList(EPApp.class,
334 " where ( enabled = 'Y' or id = " + ECOMP_APP_ID + ")", "name", null)).thenReturn(appsList);
335 List<AppsResponse> actual = epAppCommonServiceImpl.getAllApps(false);
336 assertEquals(expected.size(), actual.size());
340 public void getAppTest() {
341 EPApp expected = mockApp();
342 Mockito.when((EPApp) dataAccessService.getDomainObject(EPApp.class, expected.getId(), null))
343 .thenReturn(expected);
344 EPApp actual = epAppCommonServiceImpl.getApp(expected.getId());
345 assertEquals(expected, actual);
349 public void getAppExceptionTest() {
350 EPApp expected = mockApp();
351 Mockito.doThrow(new NullPointerException()).when(dataAccessService).getDomainObject(EPApp.class,
352 expected.getId(), null);
353 EPApp actual = epAppCommonServiceImpl.getApp(expected.getId());
357 @SuppressWarnings("unchecked")
359 public void getAppDetailTest() {
360 EPApp expected = mockApp();
361 List<EPApp> appList = new ArrayList<>();
362 appList.add(expected);
363 final Map<String, String> params = new HashMap<String, String>();
364 params.put("appName", expected.getName());
365 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getMyloginAppDetails", params, null))
366 .thenReturn(appList);
367 EPApp actual = epAppCommonServiceImpl.getAppDetail(expected.getName());
368 assertEquals(expected, actual);
372 public void getAppDetailExceptionTest() {
373 EPApp expected = mockApp();
374 List<EPApp> appList = new ArrayList<>();
375 appList.add(expected);
376 final Map<String, String> params = new HashMap<String, String>();
377 params.put("appName", expected.getName());
378 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery("getMyloginAppDetails",
380 EPApp actual = epAppCommonServiceImpl.getAppDetail(expected.getName());
385 public void getUserProfile() {
386 EPUser user = mockUser.mockEPUser();
387 final Map<String, String> params = new HashMap<>();
388 params.put("org_user_id", user.getOrgUserId());
389 List<UserRole> userRoleList = new ArrayList<>();
390 UserRole userRole = new UserRole();
391 userRole.setFirstName("GuestT");
392 userRole.setLastName("GuestT");
393 userRole.setOrgUserId("guestT");
394 userRole.setRoleId(1l);
395 userRole.setRoleName("Test");
396 userRole.setUser_Id(-1l);
397 userRoleList.add(userRole);
398 UserRoles expected = new UserRoles(userRole);
399 Mockito.when(dataAccessService.executeNamedQuery("getUserRoles", params, null)).thenReturn(userRoleList);
400 UserRoles actual = epAppCommonServiceImpl.getUserProfile(user.getOrgUserId());
401 assertEquals(expected.getOrgUserId(), actual.getOrgUserId());
405 public void getUserProfileNullTest() {
406 EPUser user = mockUser.mockEPUser();
407 final Map<String, String> params = new HashMap<>();
408 params.put("org_user_id", user.getOrgUserId());
409 List<UserRole> userRoleList = new ArrayList<>();
410 Mockito.when(dataAccessService.executeNamedQuery("getUserRoles", params, null)).thenReturn(userRoleList);
411 UserRoles actual = epAppCommonServiceImpl.getUserProfile(user.getOrgUserId());
416 public void getUserProfileNormalizedTest() {
417 EPUser user = mockUser.mockEPUser();
419 user.setLoginId("guestT");
420 final Map<String, String> params = new HashMap<>();
421 params.put("org_user_id", user.getOrgUserId());
422 List<UserRole> userRoleList = new ArrayList<>();
423 UserRole userRole = new UserRole();
424 userRole.setFirstName("GuestT");
425 userRole.setLastName("GuestT");
426 userRole.setOrgUserId("guestT");
427 userRole.setRoleId(1l);
428 userRole.setRoleName("Test");
429 userRole.setUser_Id(-1l);
430 userRoleList.add(userRole);
431 UserRoles expected = new UserRoles(userRole);
432 Mockito.when(dataAccessService.executeNamedQuery("getUserRoles", params, null)).thenReturn(userRoleList);
433 UserRoles actual = epAppCommonServiceImpl.getUserProfileNormalized(user);
434 assertEquals(expected.getOrgUserId(), actual.getOrgUserId());
438 public void getRestrictedAppRolesTest() {
439 EPUser user = mockUser.mockEPUser();
440 EPApp mockApp = mockApp();
441 mockApp.setRestrictedApp(true);
442 user.setLoginId("guestT");
443 List<LocalRole> expected = new ArrayList<>();
444 LocalRole localRole = new LocalRole();
445 localRole.setRoleId(1);
446 localRole.setRolename("test1");
447 expected.add(localRole);
448 String sql = "SELECT ROLE_ID, ROLE_NAME from FN_ROLE where UPPER(ACTIVE_YN) = 'Y' AND ROLE_ID = '"
449 + RESTRICTED_APP_ROLE_ID + "'";
450 Mockito.when(dataAccessService.executeSQLQuery(sql, LocalRole.class, null)).thenReturn(expected);
451 Mockito.when((EPApp) dataAccessService.getDomainObject(EPApp.class, mockApp.getId(), null)).thenReturn(mockApp);
452 List<LocalRole> actual = epAppCommonServiceImpl.getAppRoles(mockApp.getId());
453 assertEquals(expected, actual);
457 public void getPoralAppRolesTest() {
458 EPUser user = mockUser.mockEPUser();
459 EPApp mockApp = mockApp();
460 mockApp.setRestrictedApp(false);
462 user.setLoginId("guestT");
463 List<LocalRole> expected = new ArrayList<>();
464 LocalRole localRole = new LocalRole();
465 localRole.setRoleId(1);
466 localRole.setRolename("test1");
467 expected.add(localRole);
468 String sql = "SELECT ROLE_ID, ROLE_NAME from FN_ROLE where UPPER(ACTIVE_YN) = 'Y' AND APP_ID IS NULL";
469 Mockito.when(dataAccessService.executeSQLQuery(sql, LocalRole.class, null)).thenReturn(expected);
470 Mockito.when((EPApp) dataAccessService.getDomainObject(EPApp.class, mockApp.getId(), null)).thenReturn(mockApp);
471 List<LocalRole> actual = epAppCommonServiceImpl.getAppRoles(mockApp.getId());
472 assertEquals(expected, actual);
476 public void getNonPortalAndNonRestrictedAppRolesTest() {
477 EPUser user = mockUser.mockEPUser();
478 EPApp mockApp = mockApp();
479 mockApp.setRestrictedApp(false);
481 user.setLoginId("guestT");
482 List<LocalRole> expected = new ArrayList<>();
483 LocalRole localRole = new LocalRole();
484 localRole.setRoleId(1);
485 localRole.setRolename("test1");
486 expected.add(localRole);
487 String sql = "SELECT ROLE_ID, ROLE_NAME from FN_ROLE where UPPER(ACTIVE_YN) = 'Y' AND APP_ID = '"
488 + mockApp.getId() + "'";
489 Mockito.when(dataAccessService.executeSQLQuery(sql, LocalRole.class, null)).thenReturn(expected);
490 Mockito.when((EPApp) dataAccessService.getDomainObject(EPApp.class, mockApp.getId(), null)).thenReturn(mockApp);
491 List<LocalRole> actual = epAppCommonServiceImpl.getAppRoles(mockApp.getId());
492 assertEquals(expected, actual);
496 public void getAdminAppsTest() {
497 EPUser user = mockUser.mockEPUser();
499 List<AppIdAndNameTransportModel> expected = new ArrayList<>();
500 AppIdAndNameTransportModel appIdAndNameTransportModel = new AppIdAndNameTransportModel();
501 appIdAndNameTransportModel.setId(1l);
502 appIdAndNameTransportModel.setName("test1");
503 expected.add(appIdAndNameTransportModel);
504 Mockito.when(adminRolesServiceImpl.isAccountAdmin(user)).thenReturn(true);
505 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 "
506 + "where userrole.USER_ID = %d AND userrole.ROLE_ID=" + ACCOUNT_ADMIN_ROLE_ID
507 + " AND (app.ENABLED = 'Y' OR app.APP_ID=1)";
508 String sql = String.format(format, user.getId());
509 Mockito.when(dataAccessService.executeSQLQuery(sql, AppIdAndNameTransportModel.class, null))
510 .thenReturn(expected);
511 List<AppIdAndNameTransportModel> actual = epAppCommonServiceImpl.getAdminApps(user);
512 assertEquals(expected, actual);
516 public void getAdminAppsExceptionTest() {
517 EPUser user = mockUser.mockEPUser();
519 List<AppIdAndNameTransportModel> expected = new ArrayList<>();
520 Mockito.when(adminRolesServiceImpl.isAccountAdmin(user)).thenReturn(true);
521 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 "
522 + "where userrole.USER_ID = %d AND userrole.ROLE_ID=" + ACCOUNT_ADMIN_ROLE_ID
523 + " AND (app.ENABLED = 'Y' OR app.APP_ID=1)";
524 String sql = String.format(format, user.getId());
525 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeSQLQuery(sql,
526 AppIdAndNameTransportModel.class, null);
527 List<AppIdAndNameTransportModel> actual = epAppCommonServiceImpl.getAdminApps(user);
528 assertEquals(expected, actual);
532 @SuppressWarnings("unchecked")
534 public void addOnboardingAppUnKnownHostExceptionTest() throws Exception {
535 PowerMockito.mockStatic(PortalApiConstants.class);
536 PowerMockito.mockStatic(PortalApiProperties.class);
537 EPUser user = mockUser.mockEPUser();
538 List<EPApp> mockAppList = new ArrayList<>();
539 OnboardingApp onboardApp = new OnboardingApp();
540 onboardApp.setRestrictedApp(false);
541 onboardApp.name = "test1";
542 onboardApp.url = "http://test.com";
543 onboardApp.isOpen = false;
544 onboardApp.isEnabled = true;
545 onboardApp.username = "test123";
546 onboardApp.appPassword = "test123";
547 List<Criterion> restrictionsList = new ArrayList<Criterion>();
548 Criterion urlCrit = Restrictions.eq("url", onboardApp.url);
549 Criterion nameCrit = Restrictions.eq("name", onboardApp.name);
550 Criterion orCrit = Restrictions.or(urlCrit, nameCrit);
551 restrictionsList.add(orCrit);
552 List<String> uebList = new ArrayList<>();
553 uebList.add("localhost");
554 com.att.nsa.apiClient.credentials.ApiCredential apiCredential = new ApiCredential(user.getEmail(),
555 "ECOMP Portal Owner");
556 CambriaIdentityManager mockIm = Mockito
557 .spy(new CambriaClientBuilders.IdentityManagerBuilder().usingHosts(uebList).build());
558 Mockito.doReturn(apiCredential).when(mockIm).createApiKey(user.getEmail(), "ECOMP Portal Owner");
559 Mockito.when(PortalApiProperties.getProperty(PortalApiConstants.UEB_URL_LIST)).thenReturn("localhost");
560 Mockito.when((List<EPApp>) dataAccessService.getList(EPApp.class, null, restrictionsList, null))
561 .thenReturn(mockAppList);
562 FieldsValidator expected = new FieldsValidator();
563 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
564 FieldsValidator actual = epAppCommonServiceImpl.addOnboardingApp(onboardApp, user);
565 assertEquals(expected, actual);
568 @SuppressWarnings("unchecked")
570 public void modifyOnboardingAppTest() throws Exception {
571 EPUser user = mockUser.mockEPUser();
572 EPApp mockApp = mockApp();
573 mockApp.setName("test1");
575 mockApp.setUrl("http://test.com");
576 mockApp.setUsername("test123");
577 mockApp.setAppPassword("test123");
578 mockApp.setRestrictedApp(false);
579 mockApp.setEnabled(true);
580 mockApp.setOpen(false);
581 List<EPApp> mockAppList = new ArrayList<>();
582 mockAppList.add(mockApp);
583 OnboardingApp onboardApp = new OnboardingApp();
584 onboardApp.setRestrictedApp(false);
585 onboardApp.name = "test1";
587 onboardApp.url = "http://test.com";
588 onboardApp.isOpen = false;
589 onboardApp.isEnabled = true;
590 onboardApp.thumbnail = "test123imgthumbnail";
591 onboardApp.username = "test123";
592 onboardApp.appPassword = "test123";
593 onboardApp.isCentralAuth=true;
594 onboardApp.myLoginsAppName="test123";
595 onboardApp.myLoginsAppOwner="test123";
597 List<Criterion> restrictionsList1 = new ArrayList<Criterion>();
598 Criterion idCrit = Restrictions.eq("id", onboardApp.id);
599 Criterion urlCrit = Restrictions.eq("url", onboardApp.url);
600 Criterion nameCrit = Restrictions.eq("name", onboardApp.name);
601 Criterion orCrit = Restrictions.or(idCrit, urlCrit, nameCrit);
602 restrictionsList1.add(orCrit);
603 Mockito.when((List<EPApp>) dataAccessService.getList(EPApp.class, null, restrictionsList1, null))
604 .thenReturn(mockAppList);
605 Mockito.when((EPApp) session.get(EPApp.class, onboardApp.id)).thenReturn(mockApp);
606 String sql = "SELECT m.menu_id, m.column_num, m.text, m.parent_menu_id, m.url, m.active_yn "
607 + "FROM fn_menu_functional m, fn_menu_functional_roles r " + "WHERE m.menu_id = r.menu_id "
608 + " AND r.app_id = '" + onboardApp.id + "' ";
609 List<Integer> roles = new ArrayList<>();
612 List<FunctionalMenuItem> menuItems = new ArrayList<>();
613 FunctionalMenuItem functionalMenuItem = new FunctionalMenuItem();
614 functionalMenuItem.setRestrictedApp(false);
615 functionalMenuItem.setUrl("http://test1.com");
616 functionalMenuItem.setRoles(roles);
617 menuItems.add(functionalMenuItem);
618 Mockito.when(dataAccessService.executeSQLQuery(sql, FunctionalMenuItem.class, null)).thenReturn(menuItems);
619 Mockito.when((FunctionalMenuItem) session.get(FunctionalMenuItem.class, functionalMenuItem.menuId))
620 .thenReturn(functionalMenuItem);
621 FieldsValidator expected = new FieldsValidator();
622 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
623 FieldsValidator actual = epAppCommonServiceImpl.modifyOnboardingApp(onboardApp, user);
624 assertEquals(expected, actual);
628 public void saveWidgetsSortManualTest() {
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(1l);
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 saveWidgetsSortManualExistingRecordTest() {
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.saveWidgetsSortManual(epWidgetsSortPreferenceList, user);
688 assertEquals(expected, actual);
692 public void deleteUserWidgetSortPrefTest() {
693 EPUser user = mockUser.mockEPUser();
694 List<EPWidgetsManualSortPreference> mockEPManualWidgets = new ArrayList<>();
695 EPWidgetsManualSortPreference epWidgetsManualSortPreference = new EPWidgetsManualSortPreference();
696 epWidgetsManualSortPreference.setUserId(user.getId());
697 epWidgetsManualSortPreference.setWidgetCol(1);
698 epWidgetsManualSortPreference.setWidgetHeight(1);
699 epWidgetsManualSortPreference.setWidgetId(2l);
700 epWidgetsManualSortPreference.setWidgetRow(1);
701 epWidgetsManualSortPreference.setWidgetWidth(1);
702 mockEPManualWidgets.add(epWidgetsManualSortPreference);
703 final Map<String, Long> params = new HashMap<>();
704 params.put("userId", user.getId());
705 Mockito.when(dataAccessService.executeNamedQuery("userWidgetManualSortPrfQuery", params, null))
706 .thenReturn(mockEPManualWidgets);
707 FieldsValidator expected = new FieldsValidator();
708 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
709 List<EPWidgetsSortPreference> epWidgetsSortPreferenceList = new ArrayList<>();
710 EPWidgetsSortPreference mockEPWidgetsSortPreference = new EPWidgetsSortPreference();
711 mockEPWidgetsSortPreference.setRow(2);
712 mockEPWidgetsSortPreference.setHeaderText("test");
713 mockEPWidgetsSortPreference.setSizeX(2);
714 mockEPWidgetsSortPreference.setSizeY(2);
715 mockEPWidgetsSortPreference.setWidgetid(2l);
716 mockEPWidgetsSortPreference.setWidgetIdentifier("test");
717 mockEPWidgetsSortPreference.setCol(2);
718 epWidgetsSortPreferenceList.add(mockEPWidgetsSortPreference);
719 FieldsValidator actual = epAppCommonServiceImpl.deleteUserWidgetSortPref(epWidgetsSortPreferenceList, user);
720 assertEquals(expected, actual);
724 public void saveAppsSortPreferenceForNewUserTest() {
725 EPUser user = mockUser.mockEPUser();
726 List<EPUserAppsSortPreference> mockEPAppSortPrefList = new ArrayList<>();
727 final Map<String, Long> params = new HashMap<>();
728 params.put("userId", user.getId());
729 Mockito.when(dataAccessService.executeNamedQuery("userAppsSortPreferenceQuery", params, null))
730 .thenReturn(mockEPAppSortPrefList);
731 FieldsValidator expected = new FieldsValidator();
732 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
733 EPAppsSortPreference mockEPAppsSortPreference = new EPAppsSortPreference();
734 mockEPAppsSortPreference.setIndex(1);
735 mockEPAppsSortPreference.setTitle("Last Used");
736 mockEPAppsSortPreference.setValue("L");
737 FieldsValidator actual = epAppCommonServiceImpl.saveAppsSortPreference(mockEPAppsSortPreference, user);
738 assertEquals(expected, actual);
742 public void saveAppsSortPreferenceUpdateTest() {
743 EPUser user = mockUser.mockEPUser();
744 List<EPUserAppsSortPreference> mockEPAppSortPrefList = new ArrayList<>();
745 EPUserAppsSortPreference mockEPAppSortPref = new EPUserAppsSortPreference();
746 mockEPAppSortPref.setSortPref("L");
747 mockEPAppSortPref.setId(2l);
748 mockEPAppSortPref.setUserId((int) (long) user.getId());
749 mockEPAppSortPrefList.add(mockEPAppSortPref);
750 final Map<String, Long> params = new HashMap<>();
751 params.put("userId", user.getId());
752 Mockito.when(dataAccessService.executeNamedQuery("userAppsSortPreferenceQuery", params, null))
753 .thenReturn(mockEPAppSortPrefList);
754 FieldsValidator expected = new FieldsValidator();
755 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
756 EPAppsSortPreference mockEPAppsSortPreference = new EPAppsSortPreference();
757 mockEPAppsSortPreference.setIndex(1);
758 mockEPAppsSortPreference.setTitle("Last Used");
759 mockEPAppsSortPreference.setValue("L");
760 FieldsValidator actual = epAppCommonServiceImpl.saveAppsSortPreference(mockEPAppsSortPreference, user);
761 assertEquals(expected, actual);
765 public void saveAppsSortPreferenceExceptionTest() {
766 EPUser user = mockUser.mockEPUser();
767 final Map<String, Long> params = new HashMap<>();
768 params.put("userId", user.getId());
769 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
770 FieldsValidator expected = new FieldsValidator();
771 expected.setHttpStatusCode(500l);
772 //expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
773 EPAppsSortPreference mockEPAppsSortPreference = new EPAppsSortPreference();
774 mockEPAppsSortPreference.setIndex(1);
775 mockEPAppsSortPreference.setTitle("Last Used");
776 mockEPAppsSortPreference.setValue("L");
777 FieldsValidator actual = epAppCommonServiceImpl.saveAppsSortPreference(mockEPAppsSortPreference, user);
778 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
782 public void getUserAppsSortTypePreferenceTest() {
783 EPUser user = mockUser.mockEPUser();
784 final Map<String, Long> params = new HashMap<>();
785 List<EPUserAppsSortPreference> mockEPAppSortPrefList = new ArrayList<>();
786 EPUserAppsSortPreference mockEPAppSortPref = new EPUserAppsSortPreference();
787 mockEPAppSortPref.setSortPref("L");
788 mockEPAppSortPref.setId(2l);
789 mockEPAppSortPref.setUserId((int) (long) user.getId());
790 mockEPAppSortPrefList.add(mockEPAppSortPref);
791 params.put("userId", user.getId());
792 Mockito.when(dataAccessService.executeNamedQuery("userAppsSortPreferenceQuery", params, null))
793 .thenReturn(mockEPAppSortPrefList);
794 String actual = epAppCommonServiceImpl.getUserAppsSortTypePreference(user);
795 assertEquals(mockEPAppSortPref.getSortPref(), actual);
799 public void getUserAppsSortTypePreferenceExceptionTest() {
800 EPUser user = mockUser.mockEPUser();
801 final Map<String, Long> params = new HashMap<>();
802 List<EPUserAppsSortPreference> mockEPAppSortPrefList = new ArrayList<>();
803 EPUserAppsSortPreference mockEPAppSortPref = new EPUserAppsSortPreference();
804 mockEPAppSortPref.setSortPref("L");
805 mockEPAppSortPref.setId(2l);
806 mockEPAppSortPref.setUserId((int) (long) user.getId());
807 mockEPAppSortPrefList.add(mockEPAppSortPref);
808 params.put("userId", user.getId());
809 Mockito.doThrow(new NullPointerException()).when(dataAccessService)
810 .executeNamedQuery("userAppsSortPreferenceQuery", params, null);
811 String actual = epAppCommonServiceImpl.getUserAppsSortTypePreference(user);
816 public void deleteUserAppSortManualTest() {
817 EPUser user = mockUser.mockEPUser();
818 EPApp mockApp = mockApp();
820 final Map<String, Long> params = new HashMap<>();
821 List<EPUserAppsManualSortPreference> epManualApps = new ArrayList<EPUserAppsManualSortPreference>();
822 EPUserAppsManualSortPreference epManualApp = new EPUserAppsManualSortPreference();
823 epManualApp.setAppId(mockApp.getId());
824 epManualApp.setAppManualSortOrder(1);
825 epManualApp.setId(1l);
826 epManualApp.setUserId(user.getId());
827 epManualApps.add(epManualApp);
828 params.put("userId", user.getId());
829 Mockito.when(dataAccessService.executeNamedQuery("userAppsManualSortPrfQuery", params, null)).thenReturn(epManualApps);
830 EPDeleteAppsManualSortPref delAppSortManual = new EPDeleteAppsManualSortPref();
831 delAppSortManual.setAppId(mockApp.getId());
832 delAppSortManual.setPending(false);
833 delAppSortManual.setSelect(false);
834 FieldsValidator actual = epAppCommonServiceImpl.deleteUserAppSortManual(delAppSortManual, user);
835 FieldsValidator expected = new FieldsValidator();
836 expected.setHttpStatusCode(200l);
837 assertEquals(expected, actual);
841 public void deleteUserAppSortManualExceptionTest() {
842 EPUser user = mockUser.mockEPUser();
843 EPApp mockApp = mockApp();
845 final Map<String, Long> params = new HashMap<>();
846 List<EPUserAppsManualSortPreference> epManualApps = new ArrayList<EPUserAppsManualSortPreference>();
847 EPUserAppsManualSortPreference epManualApp = new EPUserAppsManualSortPreference();
848 epManualApp.setAppId(mockApp.getId());
849 epManualApp.setAppManualSortOrder(1);
850 epManualApp.setId(1l);
851 epManualApp.setUserId(user.getId());
852 epManualApps.add(epManualApp);
853 params.put("userId", user.getId());
854 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery("userAppsManualSortPrfQuery", params, null);
855 EPDeleteAppsManualSortPref delAppSortManual = new EPDeleteAppsManualSortPref();
856 delAppSortManual.setAppId(mockApp.getId());
857 delAppSortManual.setPending(false);
858 delAppSortManual.setSelect(false);
859 FieldsValidator actual = epAppCommonServiceImpl.deleteUserAppSortManual(delAppSortManual, user);
860 FieldsValidator expected = new FieldsValidator();
861 expected.setHttpStatusCode(500l);
862 assertEquals(expected, actual);
865 @SuppressWarnings("unchecked")
867 public void getAppDetailByAppNameTest(){
868 String appName = "test";
869 EPApp expectedResult = mockApp();
870 List<EPApp> appList = new ArrayList<>();
871 appList.add(expectedResult);
872 final Map<String, String> params = new HashMap<String, String>();
873 params.put("appName", expectedResult.getName());
874 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAppDetailsByAppName", params, null))
875 .thenReturn(appList);
876 EPApp actualResult = epAppCommonServiceImpl.getAppDetailByAppName(appName);
877 assertEquals(expectedResult, actualResult);
880 @SuppressWarnings("unchecked")
882 public void getAppDetailByAppNameExceptionTest(){
883 String appName = null;
884 EPApp expectedResult = null;
885 List<EPApp> appList = new ArrayList<>();
886 appList.add(expectedResult);
887 final Map<String, String> params = new HashMap<String, String>();
888 params.put("appName", null);
889 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAppDetailsByAppName", params, null))
890 .thenReturn(appList);
891 EPApp actualResult = epAppCommonServiceImpl.getAppDetailByAppName(appName);
892 assertEquals(expectedResult, actualResult);
895 @SuppressWarnings("unchecked")
897 public void getAppsForSuperAdminAndAccountAdminTest(){
898 String sql = "SELECT app.APP_ID, app.APP_NAME, app.APP_TYPE FROM FN_APP app "
899 + "where app.ENABLED = 'Y' AND app.app_type = 1";
900 EPUser user = mockUser.mockEPUser();
901 List<AppIdAndNameTransportModel> expected = null;
902 Mockito.when(adminRolesServiceImpl.isSuperAdmin(user)).thenReturn(true);
903 Mockito.when(adminRolesServiceImpl.isAccountAdmin(user)).thenReturn(true);
904 List<AppIdAndNameTransportModel> actual = null;
905 Mockito.when((List<AppIdAndNameTransportModel>) dataAccessService.executeSQLQuery(sql, AppIdAndNameTransportModel.class, null))
907 actual = epAppCommonServiceImpl.getAppsForSuperAdminAndAccountAdmin(user);
908 assertEquals(expected, actual);
911 @SuppressWarnings("unchecked")
913 public void getAppsForSuperAdminAndNotAccountAdminTest(){
914 String sql = "SELECT app.APP_ID, app.APP_NAME, app.APP_TYPE FROM FN_APP app "
915 + "where app.ENABLED = 'Y' AND app.app_type = 1";
916 EPUser user = mockUser.mockEPUser();
917 List<AppIdAndNameTransportModel> expected = new ArrayList<AppIdAndNameTransportModel>();
918 Mockito.when(adminRolesServiceImpl.isSuperAdmin(user)).thenReturn(false);
919 Mockito.when(adminRolesServiceImpl.isAccountAdmin(user)).thenReturn(true);
920 List<AppIdAndNameTransportModel> actual = null;
921 Mockito.when((List<AppIdAndNameTransportModel>) dataAccessService.executeSQLQuery(sql, AppIdAndNameTransportModel.class, null))
923 actual = epAppCommonServiceImpl.getAppsForSuperAdminAndAccountAdmin(user);
924 assertEquals(expected, actual);
927 @SuppressWarnings("unchecked")
929 public void getAppsForAdminAndAccountAdminTest(){
930 String sql = "SELECT app.APP_ID, app.APP_NAME, app.APP_TYPE FROM FN_APP app "
931 + "where app.ENABLED = 'Y' AND app.app_type = 1";
932 EPUser user = mockUser.mockEPUser();
933 List<AppIdAndNameTransportModel> expected = null;
934 Mockito.when(adminRolesServiceImpl.isSuperAdmin(user)).thenReturn(true);
935 List<AppIdAndNameTransportModel> actual = null;
936 Mockito.when((List<AppIdAndNameTransportModel>) dataAccessService.executeSQLQuery(sql, AppIdAndNameTransportModel.class, null))
938 actual = epAppCommonServiceImpl.getAppsForSuperAdminAndAccountAdmin(user);
939 assertEquals(expected, actual);
943 public void getAppsForSuperAdminAndAccountAdminExceptionTest(){
944 String sql = "SELECT app.APP_ID, app.APP_NAME, app.APP_TYPE FROM FN_APP app "
945 + "where app.ENABLED = 'Y' AND app.app_type = 1";
946 EPUser user = mockUser.mockEPUser();
947 List<AppIdAndNameTransportModel> expected = new ArrayList<AppIdAndNameTransportModel>();
948 Mockito.when(adminRolesServiceImpl.isSuperAdmin(user)).thenReturn(true);
949 List<AppIdAndNameTransportModel> actual = null;
950 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeSQLQuery(sql, AppIdAndNameTransportModel.class, null);
951 actual = epAppCommonServiceImpl.getAppsForSuperAdminAndAccountAdmin(user);
952 assertEquals(expected, actual);
956 public void getDataAccessServiceTest(){
957 assertEquals(epAppCommonServiceImpl.getDataAccessService(), epAppCommonServiceImpl.getDataAccessService());
960 @SuppressWarnings("unchecked")
962 public void getAppsAdminsTest(){
963 List<AdminUserApplications> expected = new ArrayList<AdminUserApplications>();
964 List<AdminUserApplications> actual = null;
965 List<AdminUserApp> list = new ArrayList<AdminUserApp>();
966 Map<String, String> params = new HashMap<>();
967 params.put("accountAdminRoleId", ACCOUNT_ADMIN_ROLE_ID);
968 Mockito.when((List<AdminUserApp>) dataAccessService.executeNamedQuery("getAppsAdmins", params, null)).thenReturn(list);
969 actual = epAppCommonServiceImpl.getAppsAdmins();
970 assertEquals(expected, actual);
974 public void getAppsAdminsExceptionTest(){
975 List<AdminUserApplications> expected = null;
976 List<AdminUserApplications> actual = null;
977 Map<String, String> params = new HashMap<>();
978 params.put("accountAdminRoleId", ACCOUNT_ADMIN_ROLE_ID);
979 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery("getAppsAdmins", params, null);
980 actual = epAppCommonServiceImpl.getAppsAdmins();
981 assertEquals(expected, actual);
984 @SuppressWarnings("unchecked")
986 public void getAppsAdminsAggregateResultsTest(){
987 List<AdminUserApplications> expected = new ArrayList<AdminUserApplications>();
988 AdminUserApp adminUserApp = new AdminUserApp();
989 AdminUserApplications adminUserApplications = new AdminUserApplications(adminUserApp);
990 expected.add(adminUserApplications);
991 List<AdminUserApplications> actual = null;
992 List<AdminUserApp> list = new ArrayList<AdminUserApp>();
993 AdminUserApp adminUserApp1 = new AdminUserApp();
994 list.add(adminUserApp1);
995 Map<String, String> params = new HashMap<>();
996 params.put("accountAdminRoleId", ACCOUNT_ADMIN_ROLE_ID);
997 Mockito.when((List<AdminUserApp>) dataAccessService.executeNamedQuery("getAppsAdmins", params, null)).thenReturn(list);
998 actual = epAppCommonServiceImpl.getAppsAdmins();
999 assertEquals(expected.size(), actual.size());
1002 @SuppressWarnings("unchecked")
1004 public void getUserAppsTest(){
1006 EPApp epApp = new EPApp();
1007 epApp.setOpen(false);
1008 List<EPApp> expected = new ArrayList<EPApp>();
1009 List<EPApp> list = new ArrayList<EPApp>();
1010 EPUser epUser = new EPUser();
1012 Mockito.when((List<EPApp>) dataAccessService.executeSQLQuery(sql, EPApp.class, null)).thenReturn(list);
1013 List<EPApp> actual = epAppCommonServiceImpl.getUserApps(epUser);
1014 assertEquals(expected.size(), actual.size());
1017 @SuppressWarnings("unchecked")
1019 public void getUserAppsUserGuestTest(){
1021 List<EPApp> expected = new ArrayList<EPApp>();
1022 List<EPApp> list = new ArrayList<EPApp>();
1023 EPUser epUser = new EPUser();
1024 epUser.setGuest(true);
1025 Mockito.when((List<EPApp>) dataAccessService.executeSQLQuery(sql, EPApp.class, null)).thenReturn(list);
1026 List<EPApp> actual = epAppCommonServiceImpl.getUserApps(epUser);
1027 assertEquals(expected.size(), actual.size());
1030 @SuppressWarnings("unchecked")
1032 public void getPersAdminAppsTest(){
1033 List<EPApp> expected = new ArrayList<EPApp>();
1034 final Map<String, Long> params = new HashMap<>();
1035 params.put("userId", (long)123);
1036 EPUser epUser = new EPUser();
1037 List<EPApp> list = new ArrayList<EPApp>();
1038 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getPersAdminApps", params, null)).thenReturn(list);
1039 List<EPApp> actual = epAppCommonServiceImpl.getPersAdminApps(epUser);
1040 assertEquals(expected, actual);
1043 @SuppressWarnings("unchecked")
1045 public void getPersUserAppsTest(){
1046 List<EPApp> expected = new ArrayList<EPApp>();
1047 EPUser epUser = new EPUser();
1048 final Map<String, Long> params = new HashMap<>();
1049 params.put("userId", (long)123);
1050 List<EPApp> list = new ArrayList<EPApp>();
1051 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getPersUserApps", params, null)).thenReturn(list);
1052 List<EPApp> actual = epAppCommonServiceImpl.getPersUserApps(epUser);
1053 assertEquals(expected, actual);
1056 @SuppressWarnings("unchecked")
1058 public void getUserAppCatalogTest(){
1059 List<AppCatalogItem> expected = new ArrayList<AppCatalogItem>();
1060 EPUser epUser = new EPUser();
1061 final Map<String, Long> params = new HashMap<>();
1062 params.put("userId", (long)123);
1063 List<AppCatalogItem> list = new ArrayList<AppCatalogItem>();
1064 Mockito.when((List<AppCatalogItem>) dataAccessService.executeNamedQuery("getUserAppCatalog", params, null)).thenReturn(list);
1065 List<AppCatalogItem> actual = epAppCommonServiceImpl.getUserAppCatalog(epUser);
1066 assertEquals(expected, actual);
1069 @SuppressWarnings("unchecked")
1071 public void getAdminAppCatalogTest(){
1072 List<AppCatalogItem> expected = new ArrayList<AppCatalogItem>();
1073 EPUser epUser = new EPUser();
1074 final Map<String, Long> params = new HashMap<>();
1075 params.put("userId", (long)123);
1076 List<AppCatalogItem> list = new ArrayList<AppCatalogItem>();
1077 Mockito.when((List<AppCatalogItem>) dataAccessService.executeNamedQuery("getAdminAppCatalog", params, null)).thenReturn(list);
1078 List<AppCatalogItem> actual = epAppCommonServiceImpl.getAdminAppCatalog(epUser);
1079 assertEquals(expected, actual);
1082 @SuppressWarnings("unchecked")
1084 public void getAppsOrderByNameTest(){
1085 List<EPApp> expected = new ArrayList<EPApp>();
1086 EPUser epUser = new EPUser();
1087 List<EPApp> list = new ArrayList<EPApp>();
1088 final Map<String, Long> params = new HashMap<>();
1089 params.put("userId", (long)123);
1090 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1091 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getPersAdminAppsOrderByName", params, null)).thenReturn(list);
1092 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByName(epUser);
1093 assertEquals(expected, actual);
1096 @SuppressWarnings("unchecked")
1098 public void getAppsOrderByNameNotSuperAdminTest(){
1099 List<EPApp> expected = new ArrayList<EPApp>();
1100 EPUser epUser = new EPUser();
1101 List<EPApp> list = new ArrayList<EPApp>();
1102 final Map<String, Long> params = new HashMap<>();
1103 params.put("userId", (long)123);
1104 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(false);
1105 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getPersAdminAppsOrderByName", params, null)).thenReturn(list);
1106 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByName(epUser);
1107 assertEquals(expected, actual);
1111 public void getAppsOrderByNameExceptionTest(){
1112 List<EPApp> expected = null;
1113 EPUser epUser = new EPUser();
1114 final Map<String, Long> params = new HashMap<>();
1115 params.put("userId", null);
1116 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1117 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
1118 //Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap())).thenReturn(list);
1119 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByName(epUser);
1120 assertEquals(expected, actual);
1123 @SuppressWarnings("unchecked")
1125 public void getAppsOrderByLastUsedTest(){
1126 List<EPApp> expected = new ArrayList<EPApp>();
1127 EPUser epUser = new EPUser();
1128 List<EPApp> list = new ArrayList<EPApp>();
1129 final Map<String, Long> params = new HashMap<>();
1130 params.put("userId", (long)123);
1131 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1132 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAdminAppsOrderByLastUsed", params, null)).thenReturn(list);
1133 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByLastUsed(epUser);
1134 assertEquals(expected, actual);
1137 @SuppressWarnings("unchecked")
1139 public void getAppsOrderByLastUsedNotSuperAdminTest(){
1140 List<EPApp> expected = new ArrayList<EPApp>();
1141 EPUser epUser = new EPUser();
1142 List<EPApp> list = new ArrayList<EPApp>();
1143 final Map<String, Long> params = new HashMap<>();
1144 params.put("userId", (long)123);
1145 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(false);
1146 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAdminAppsOrderByLastUsed", params, null)).thenReturn(list);
1147 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByLastUsed(epUser);
1148 assertEquals(expected, actual);
1152 public void getAppsOrderByLastUsedExceptionTest(){
1153 List<EPApp> expected = new ArrayList<EPApp>();
1154 EPUser epUser = new EPUser();
1155 final Map<String, Long> params = new HashMap<>();
1156 params.put("userId", null);
1157 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
1158 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByLastUsed(epUser);
1159 assertEquals(expected, actual);
1162 @SuppressWarnings("unchecked")
1164 public void getAppsOrderByMostUsedTest(){
1165 List<EPApp> expected = new ArrayList<EPApp>();
1166 EPUser epUser = new EPUser();
1167 List<EPApp> list = new ArrayList<EPApp>();
1168 final Map<String, Long> params = new HashMap<>();
1169 params.put("userId", (long)123);
1170 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1171 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAppsOrderByMostUsed", params, null)).thenReturn(list);
1172 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByMostUsed(epUser);
1173 assertEquals(expected, actual);
1176 @SuppressWarnings("unchecked")
1178 public void getAppsOrderByMostUsedNotSuperAdminTest(){
1179 List<EPApp> expected = new ArrayList<EPApp>();
1180 EPUser epUser = new EPUser();
1181 List<EPApp> list = new ArrayList<EPApp>();
1182 final Map<String, Long> params = new HashMap<>();
1183 params.put("userId", (long)123);
1184 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(false);
1185 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAppsOrderByMostUsed", params, null)).thenReturn(list);
1186 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByMostUsed(epUser);
1187 assertEquals(expected, actual);
1191 public void getAppsOrderByMostUsedExceptionTest(){
1192 List<EPApp> expected = new ArrayList<EPApp>();
1193 EPUser epUser = new EPUser();
1194 final Map<String, Long> params = new HashMap<>();
1195 params.put("userId", null);
1196 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
1197 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByMostUsed(epUser);
1198 assertEquals(expected, actual);
1201 @SuppressWarnings("unchecked")
1203 public void getAppsOrderByManualTest(){
1204 List<EPApp> expected = new ArrayList<EPApp>();
1205 EPUser epUser = new EPUser();
1206 List<EPApp> list = new ArrayList<EPApp>();
1207 final Map<String, Long> params = new HashMap<>();
1208 params.put("userId", (long)123);
1209 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1210 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAdminAppsOrderByManual", params, null)).thenReturn(list);
1211 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByManual(epUser);
1212 assertEquals(expected, actual);
1215 @SuppressWarnings("unchecked")
1217 public void getAppsOrderByManualSuperAdminTest(){
1218 List<EPApp> expected = new ArrayList<EPApp>();
1219 EPUser epUser = new EPUser();
1220 List<EPApp> list = new ArrayList<EPApp>();
1221 final Map<String, Long> params = new HashMap<>();
1222 params.put("userId", (long)123);
1223 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(false);
1224 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAdminAppsOrderByManual", params, null)).thenReturn(list);
1225 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByManual(epUser);
1226 assertEquals(expected, actual);
1229 @SuppressWarnings("unchecked")
1231 public void getAppsOrderByManualExceptionTest(){
1232 List<EPApp> expected = new ArrayList<EPApp>();
1233 EPUser epUser = new EPUser();
1234 List<EPApp> list = new ArrayList<EPApp>();
1235 final Map<String, Long> params = new HashMap<>();
1236 params.put("userId", null);
1237 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1238 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
1239 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByManual(epUser);
1240 assertEquals(expected, actual);
1243 @SuppressWarnings("deprecation")
1245 public void getOnboardingAppsTest(){
1246 List<EPApp> apps = new ArrayList<EPApp>();
1247 List<OnboardingApp> expected = new ArrayList<OnboardingApp>();
1248 Mockito.when(dataAccessService.getList(EPApp.class, " where id!=" + ECOMP_APP_ID, null, null)).thenReturn(apps);
1249 List<OnboardingApp> actual = epAppCommonServiceImpl.getOnboardingApps();
1250 assertEquals(expected, actual);
1254 public void getEnabledNonOpenOnboardingAppsTest(){
1255 List<OnboardingApp> expected = new ArrayList<OnboardingApp>();
1256 List<OnboardingApp> actual = epAppCommonServiceImpl.getEnabledNonOpenOnboardingApps();
1257 assertEquals(expected, actual);
1261 public void addOnboardingAppTest(){
1262 FieldsValidator expected = new FieldsValidator();
1263 expected.setHttpStatusCode(400l);
1264 EPUser epUser = new EPUser();
1265 OnboardingApp onboardingApp = new OnboardingApp();
1267 onboardingApp.setRestrictedApp(true);
1268 onboardingApp.isCentralAuth=false;
1269 FieldsValidator actual = epAppCommonServiceImpl.addOnboardingApp(onboardingApp, epUser);
1270 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
1274 public void deleteOnboardingAppTest(){
1275 FieldsValidator expected = new FieldsValidator();
1276 expected.setHttpStatusCode(403l);
1277 EPUser epUser = new EPUser();
1278 Long appId = (long) 123;
1279 OnboardingApp onboardingApp = new OnboardingApp();
1280 onboardingApp.setRestrictedApp(true);
1281 FieldsValidator actual = epAppCommonServiceImpl.deleteOnboardingApp(epUser, appId);
1282 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
1285 @SuppressWarnings("unchecked")
1287 public void deleteOnboardingAppSuperAdminTest(){
1288 FieldsValidator expected = new FieldsValidator();
1289 expected.setHttpStatusCode(200l);
1290 EPUser epUser = new EPUser();
1291 Long appId = (long) 123;
1292 OnboardingApp onboardingApp = new OnboardingApp();
1293 onboardingApp.setRestrictedApp(true);
1294 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1295 final Map<String, Long> params = new HashMap<>();
1296 params.put("app_id", (long)123);
1297 EPUserAppRolesRequest epUserAppRolesRequest = new EPUserAppRolesRequest();
1298 epUserAppRolesRequest.setUserId((long)123);
1299 List<EPUserAppRolesRequest> list= new ArrayList<>();
1300 list.add(epUserAppRolesRequest);
1301 Mockito.when((List<EPUserAppRolesRequest>) dataAccessService.executeNamedQuery("getRequestIdsForApp", params, null)).thenReturn(list);
1302 FieldsValidator actual = epAppCommonServiceImpl.deleteOnboardingApp(epUser, appId);
1303 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
1306 @Test(expected=NullPointerException.class)
1307 public void deleteOnboardingAppExceptionTest(){
1308 FieldsValidator expected = new FieldsValidator();
1309 expected.setHttpStatusCode(200l);
1310 EPUser epUser = new EPUser();
1311 //Long appId = (long) 123;
1312 List<EPUserAppRolesRequest> epUserAppRolesRequestList= new ArrayList<>();
1313 OnboardingApp onboardingApp = new OnboardingApp();
1314 onboardingApp.setRestrictedApp(true);
1315 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1316 final Map<String, Long> params = new HashMap<>();
1317 params.put("app_id", null);
1318 Mockito.when(dataAccessService.executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap())).thenThrow(nullPointerException);
1319 Mockito.when(dataAccessService.executeNamedQuery( "getRequestIdsForApp", params, null)).thenReturn(epUserAppRolesRequestList);
1320 //Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
1321 FieldsValidator actual = epAppCommonServiceImpl.deleteOnboardingApp(epUser, null);
1322 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
1325 @SuppressWarnings("unchecked")
1327 public void saveAppsSortManualAppIdNullTest(){
1328 List<EPUserAppsManualSortPreference> epUserAppsManualSortPreferenceList = new ArrayList<EPUserAppsManualSortPreference>();
1329 EPAppsManualPreference epAppsManualPreference = new EPAppsManualPreference();
1330 epAppsManualPreference.setAddRemoveApps(true);
1331 epAppsManualPreference.setAppid((long)123);
1332 FieldsValidator expected = new FieldsValidator();
1333 expected.setHttpStatusCode(200l);
1334 final Map<String, Long> params = new HashMap<>();
1335 params.put("userId", (long)123);
1336 EPUser epUser = new EPUser();
1337 List<EPAppsManualPreference> list = new ArrayList<EPAppsManualPreference>();
1338 list.add(epAppsManualPreference);
1339 Mockito.when(dataAccessService.executeNamedQuery("userAppsManualSortPrfQuery", params, null)).thenReturn(epUserAppsManualSortPreferenceList);
1340 FieldsValidator actual = epAppCommonServiceImpl.saveAppsSortManual(list, epUser);
1341 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
1345 public void saveAppsSortManualExceptionTest(){
1346 FieldsValidator expected = new FieldsValidator();
1347 expected.setHttpStatusCode(500l);
1348 final Map<String, Long> params = new HashMap<>();
1349 params.put("userId", (long)123);
1350 EPUser epUser = new EPUser();
1351 List<EPAppsManualPreference> list = new ArrayList<EPAppsManualPreference>();
1352 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
1353 FieldsValidator actual = epAppCommonServiceImpl.saveAppsSortManual(list, epUser);
1354 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
1358 public void getUserProfileForLeftMenuNullListTest(){
1359 UserRole userRole =new UserRole();
1360 userRole.setFirstName("test");
1361 UserRoles expected = null;
1362 UserRoles actual = epAppCommonServiceImpl.getUserProfileForLeftMenu("123");
1363 assertEquals(expected, actual);
1367 public void getUserProfileForLeftMenuTest(){
1368 final Map<String, String> params = new HashMap<>();
1369 params.put("org_user_id", "test");
1370 UserRole userRole =new UserRole();
1371 userRole.setFirstName("test");
1372 UserRoles expected = null;
1373 List<UserRole> list = new ArrayList<UserRole>();
1375 Mockito.when(dataAccessService.executeNamedQuery( "getUserRolesForLeftMenu", params, null)).thenReturn(list);
1376 UserRoles actual = epAppCommonServiceImpl.getUserProfileForLeftMenu("123");
1377 assertEquals(expected, actual);
1381 public void getUserProfileForRolesLeftMenuNullListTest(){
1382 UserRoles expected = null;
1383 List<UserRole> userRoleList = new ArrayList<UserRole>();
1384 final Map<String, String> params = new HashMap<>();
1385 params.put("org_user_id", "test");
1386 Mockito.when(dataAccessService.executeNamedQuery( "getRolesForLeftMenu", params, null)).thenReturn(userRoleList);
1387 UserRoles actual = epAppCommonServiceImpl.getUserProfileForRolesLeftMenu("test");
1388 assertEquals(expected, actual);
1392 public void getUserProfileForRolesLeftMenuTest(){
1393 UserRole userRole = new UserRole();
1394 userRole.setRoleId((long)123);
1395 userRole.setOrgUserId("test");
1396 userRole.setUser_Id((long)1);
1397 List<UserRole> userRoleList = new ArrayList<UserRole>();
1398 userRoleList.add(userRole);
1399 UserRoles expected = new UserRoles(userRole);
1400 final Map<String, String> params = new HashMap<>();
1401 params.put("org_user_id", "test");
1402 Mockito.when(dataAccessService.executeNamedQuery( "getRolesForLeftMenu", params, null)).thenReturn(userRoleList);
1403 UserRoles actual = epAppCommonServiceImpl.getUserProfileForRolesLeftMenu("test");
1404 assertEquals(expected.getOrgUserId(), actual.getOrgUserId());
1408 public void getUserProfileNormalizedForLeftMenuNullListTest(){
1409 EPUser epUser = new EPUser();
1410 List<String> list = new ArrayList<String>();
1412 UserRole userRole = new UserRole();
1413 userRole.setFirstName("GuestT");
1414 userRole.setLastName("GuestT");
1415 userRole.setOrgUserId("guestT");
1416 userRole.setRoleId(1l);
1417 userRole.setRoleName("Test");
1418 userRole.setUser_Id(-1l);
1419 UserRoles expected = new UserRoles(userRole);
1420 expected.setRoles(list);
1421 UserRoles actual = epAppCommonServiceImpl.getUserProfileNormalizedForLeftMenu(epUser);
1422 assertEquals(expected.getRoles(), actual.getRoles());
1426 public void getUserProfileNormalizedForRolesLeftMenuTest(){
1427 EPUser epUser = new EPUser();
1428 List<String> list = new ArrayList<String>();
1430 UserRole userRole = new UserRole();
1431 userRole.setFirstName("GuestT");
1432 userRole.setLastName("GuestT");
1433 userRole.setOrgUserId("guestT");
1434 userRole.setRoleId(1l);
1435 userRole.setRoleName("Test");
1436 userRole.setUser_Id(-1l);
1437 UserRoles expected = new UserRoles(userRole);
1438 expected.setRoles(list);
1439 UserRoles actual = epAppCommonServiceImpl.getUserProfileNormalizedForRolesLeftMenu(epUser);
1440 assertEquals(expected.getRoles(), actual.getRoles());