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.json.JSONObject;
56 import org.junit.Before;
57 import org.junit.Ignore;
58 import org.junit.Test;
59 import org.junit.runner.RunWith;
60 import org.mockito.InjectMocks;
61 import org.mockito.Matchers;
62 import org.mockito.Mock;
63 import org.mockito.Mockito;
64 import org.mockito.MockitoAnnotations;
65 import org.onap.portalapp.portal.core.MockEPUser;
66 import org.onap.portalapp.portal.domain.AdminUserApp;
67 import org.onap.portalapp.portal.domain.AdminUserApplications;
68 import org.onap.portalapp.portal.domain.AppIdAndNameTransportModel;
69 import org.onap.portalapp.portal.domain.AppsResponse;
70 import org.onap.portalapp.portal.domain.EPApp;
71 import org.onap.portalapp.portal.domain.EPUser;
72 import org.onap.portalapp.portal.domain.EPUserAppRolesRequest;
73 import org.onap.portalapp.portal.domain.EPUserAppsManualSortPreference;
74 import org.onap.portalapp.portal.domain.EPUserAppsSortPreference;
75 import org.onap.portalapp.portal.domain.EPWidgetsManualSortPreference;
76 import org.onap.portalapp.portal.domain.EcompApp;
77 import org.onap.portalapp.portal.domain.UserRole;
78 import org.onap.portalapp.portal.domain.UserRoles;
79 import org.onap.portalapp.portal.ecomp.model.AppCatalogItem;
80 import org.onap.portalapp.portal.transport.EPAppsManualPreference;
81 import org.onap.portalapp.portal.transport.EPAppsSortPreference;
82 import org.onap.portalapp.portal.transport.EPDeleteAppsManualSortPref;
83 import org.onap.portalapp.portal.transport.EPWidgetsSortPreference;
84 import org.onap.portalapp.portal.transport.FieldsValidator;
85 import org.onap.portalapp.portal.transport.FunctionalMenuItem;
86 import org.onap.portalapp.portal.transport.LocalRole;
87 import org.onap.portalapp.portal.transport.OnboardingApp;
88 import org.onap.portalapp.portal.utils.EPCommonSystemProperties;
89 import org.onap.portalapp.portal.utils.EcompPortalUtils;
90 import org.onap.portalapp.portal.utils.PortalConstants;
91 import org.onap.portalsdk.core.onboarding.util.PortalApiConstants;
92 import org.onap.portalsdk.core.onboarding.util.PortalApiProperties;
93 import org.onap.portalsdk.core.service.DataAccessService;
94 import org.onap.portalsdk.core.service.DataAccessServiceImpl;
95 import org.onap.portalsdk.core.util.SystemProperties;
96 import org.powermock.api.mockito.PowerMockito;
97 import org.powermock.core.classloader.annotations.PowerMockIgnore;
98 import org.powermock.core.classloader.annotations.PrepareForTest;
99 import org.powermock.modules.junit4.PowerMockRunner;
100 import org.springframework.http.HttpEntity;
101 import org.springframework.http.HttpMethod;
102 import org.springframework.http.HttpStatus;
103 import org.springframework.http.ResponseEntity;
104 import org.springframework.web.client.RestTemplate;
106 import com.att.nsa.apiClient.credentials.ApiCredential;
107 import com.att.nsa.cambria.client.CambriaClientBuilders;
108 import com.att.nsa.cambria.client.CambriaIdentityManager;
110 @RunWith(PowerMockRunner.class)
111 @PowerMockIgnore({ "org.apache.http.conn.ssl.*", "javax.net.ssl.*", "javax.crypto.*" })
112 @PrepareForTest({ EcompPortalUtils.class, PortalApiProperties.class, PortalApiConstants.class, SystemProperties.class,
113 PortalConstants.class, EPCommonSystemProperties.class })
114 public class EPAppCommonServiceImplTest {
117 DataAccessService dataAccessService = new DataAccessServiceImpl();
120 AdminRolesServiceImpl adminRolesServiceImpl = new AdminRolesServiceImpl();
123 EPAppServiceImpl epAppServiceImpl = new EPAppServiceImpl();*/
126 SessionFactory sessionFactory;
132 Transaction transaction;
134 NullPointerException nullPointerException = new NullPointerException();
137 RestTemplate template = new RestTemplate();
140 public void setup() {
141 MockitoAnnotations.initMocks(this);
142 Mockito.when(sessionFactory.openSession()).thenReturn(session);
143 Mockito.when(session.beginTransaction()).thenReturn(transaction);
146 MockEPUser mockUser = new MockEPUser();
148 String ECOMP_APP_ID = "1";
149 String SUPER_ADMIN_ROLE_ID = "1";
150 String ACCOUNT_ADMIN_ROLE_ID = "999";
151 String RESTRICTED_APP_ROLE_ID = "900";
154 EPAppCommonServiceImpl epAppCommonServiceImpl = new EPAppCommonServiceImpl();
156 public EPApp mockApp() {
157 EPApp app = new EPApp();
159 app.setImageUrl("test");
160 app.setDescription("test");
161 app.setNotes("test");
164 app.setAppRestEndpoint("test");
165 app.setAlternateUrl("test");
167 app.setMlAppName("test");
168 app.setMlAppAdminId("test");
169 app.setUsername("test");
170 app.setAppPassword("test");
172 app.setEnabled(false);
173 app.setCentralAuth(true);
174 app.setUebKey("test");
175 app.setUebSecret("test");
176 app.setUebTopicName("test");
182 public void getUserAsAdminAppsTest() {
183 EPApp mockApp = mockApp();
184 EPApp mockApp2 = mockApp();
186 EPUser user = mockUser.mockEPUser();
187 List<EPApp> expected = new ArrayList<>();
188 expected.add(mockApp);
189 expected.add(mockApp2);
190 String sql = "SELECT * FROM FN_APP join FN_USER_ROLE ON FN_USER_ROLE.APP_ID=FN_APP.APP_ID where "
191 + "FN_USER_ROLE.USER_ID=" + user.getId() + " AND FN_USER_ROLE.ROLE_ID=" + ACCOUNT_ADMIN_ROLE_ID
192 + " AND FN_APP.ENABLED = 'Y'";
193 Mockito.when(dataAccessService.executeSQLQuery(sql, EPApp.class, null)).thenReturn(expected);
194 Mockito.when(adminRolesServiceImpl.isAccountAdmin(user)).thenReturn(true);
195 List<EPApp> actual = epAppCommonServiceImpl.getUserAsAdminApps(user);
196 assertEquals(expected, actual);
200 public void getUserAsAdminAppsTestException() {
201 List<EPApp> expected = new ArrayList<>();
202 EPUser user = mockUser.mockEPUser();
203 String sql = "SELECT * FROM FN_APP join FN_USER_ROLE ON FN_USER_ROLE.APP_ID=FN_APP.APP_ID where "
204 + "FN_USER_ROLE.USER_ID=" + user.getId() + " AND FN_USER_ROLE.ROLE_ID=" + ACCOUNT_ADMIN_ROLE_ID
205 + " AND FN_APP.ENABLED = 'Y'";
206 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeSQLQuery(sql, EPApp.class, null);
207 Mockito.when(adminRolesServiceImpl.isAccountAdmin(user)).thenReturn(false);
208 List<EPApp> actual = epAppCommonServiceImpl.getUserAsAdminApps(user);
209 assertEquals(expected, actual);
213 public void getUserByOrgUserIdAsAdminAppsTest() {
214 EPApp mockApp = mockApp();
215 EPApp mockApp2 = mockApp();
217 EPUser user = mockUser.mockEPUser();
218 List<EPApp> expected = new ArrayList<>();
219 expected.add(mockApp);
220 expected.add(mockApp2);
221 String format = "SELECT * FROM FN_APP app INNER JOIN FN_USER_ROLE userrole ON userrole.APP_ID=app.APP_ID "
222 + "INNER JOIN FN_USER user on user.USER_ID = userrole.USER_ID "
223 + "WHERE user.org_user_id = '%s' AND userrole.ROLE_ID=" + ACCOUNT_ADMIN_ROLE_ID
224 + " AND FN_APP.ENABLED = 'Y'";
225 String sql = String.format(format, user.getOrgUserId());
226 Mockito.when(dataAccessService.executeSQLQuery(sql, EPApp.class, null)).thenReturn(expected);
227 List<EPApp> actual = epAppCommonServiceImpl.getUserByOrgUserIdAsAdminApps(user.getOrgUserId());
228 assertEquals(expected, actual);
232 public void getUserByOrgUserIdAsAdminAppsTest1() {
233 EPApp mockApp = mockApp();
234 EPApp mockApp2 = mockApp();
236 EPUser user = mockUser.mockEPUser();
237 List<EPApp> expected = new ArrayList<>();
238 expected.add(mockApp);
239 expected.add(mockApp2);
240 String format = "SELECT * FROM FN_APP app INNER JOIN FN_USER_ROLE userrole ON userrole.APP_ID=app.APP_ID "
241 + "INNER JOIN FN_USER user on user.USER_ID = userrole.USER_ID "
242 + "WHERE user.org_user_id = '%s' AND userrole.ROLE_ID=" + ACCOUNT_ADMIN_ROLE_ID
243 + " AND FN_APP.ENABLED = 'Y'";
244 String sql = String.format(format, user.getOrgUserId());
245 Mockito.when(dataAccessService.executeSQLQuery(sql, EPApp.class, null)).thenReturn(expected);
246 List<EPApp> actual = epAppCommonServiceImpl.getUserByOrgUserIdAsAdminApps(user.getOrgUserId());
247 assertEquals(expected, actual);
251 public void getUserByOrgUserIdAsAdminAppsTestException() {
252 EPUser user = mockUser.mockEPUser();
253 String format = "SELECT * FROM FN_APP app INNER JOIN FN_USER_ROLE userrole ON userrole.APP_ID=app.APP_ID "
254 + "INNER JOIN FN_USER user on user.USER_ID = userrole.USER_ID "
255 + "WHERE user.org_user_id = '%s' AND userrole.ROLE_ID=" + ACCOUNT_ADMIN_ROLE_ID
256 + " AND FN_APP.ENABLED = 'Y'";
257 String sql = String.format(format, user.getOrgUserId());
258 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeSQLQuery(sql, EPApp.class, null);
259 List<EPApp> actual = epAppCommonServiceImpl.getUserByOrgUserIdAsAdminApps(user.getOrgUserId());
263 @SuppressWarnings("deprecation")
265 public void getAppsFullListTest() {
266 EPApp mockApp = mockApp();
267 EPApp mockApp2 = mockApp();
269 List<EPApp> expected = new ArrayList<>();
270 expected.add(mockApp);
271 expected.add(mockApp2);
272 Mockito.when(dataAccessService.getList(EPApp.class, null)).thenReturn(expected);
273 List<EPApp> actual = epAppCommonServiceImpl.getAppsFullList();
274 assertEquals(expected, actual);
279 public void getEcompAppAppsFullListTest() {
280 List<EcompApp> expected = new ArrayList<>();
281 List<EcompApp> actual = epAppCommonServiceImpl.getEcompAppAppsFullList();
282 assertEquals(expected, actual);
286 public void transformAppsToEcompAppsTest() {
287 EPApp mockApp = mockApp();
288 EPApp mockApp2 = mockApp();
290 List<EPApp> epAppsList = new ArrayList<>();
291 epAppsList.add(mockApp);
292 epAppsList.add(mockApp2);
293 List<EcompApp> expected = new ArrayList<>();
294 EcompApp ecompApp = new EcompApp();
295 ecompApp.setName("test1");
296 EcompApp ecompApp2 = new EcompApp();
297 ecompApp2.setName("test2");
298 expected.add(ecompApp);
299 expected.add(ecompApp2);
300 List<EcompApp> actual = epAppCommonServiceImpl.transformAppsToEcompApps(epAppsList);
301 assertEquals(expected.size(), actual.size());
304 @SuppressWarnings({ "unchecked", "deprecation" })
306 public void getAllAppsForAllTest() {
307 EPApp mockApp = mockApp();
308 EPApp mockApp2 = mockApp();
310 List<EPApp> appsList = new ArrayList<>();
311 appsList.add(mockApp);
312 appsList.add(mockApp2);
313 List<AppsResponse> expected = new ArrayList<>();
314 AppsResponse appResponse1 = new AppsResponse(mockApp.getId(), mockApp.getName(), mockApp.isRestrictedApp(),
315 mockApp.getEnabled());
316 AppsResponse appResponse2 = new AppsResponse(mockApp2.getId(), mockApp2.getName(), mockApp2.isRestrictedApp(),
317 mockApp2.getEnabled());
318 expected.add(appResponse1);
319 expected.add(appResponse2);
320 Mockito.when((List<EPApp>) dataAccessService.getList(EPApp.class, " where id != " + ECOMP_APP_ID, "name", null))
321 .thenReturn(appsList);
322 List<AppsResponse> actual = epAppCommonServiceImpl.getAllApps(true);
323 assertEquals(expected.size(), actual.size());
326 @SuppressWarnings({ "unchecked", "deprecation" })
328 public void getAllAppsIsNotAllTest() {
329 EPApp mockApp = mockApp();
330 EPApp mockApp2 = mockApp();
332 List<EPApp> appsList = new ArrayList<>();
333 appsList.add(mockApp);
334 appsList.add(mockApp2);
335 Mockito.when((List<EPApp>) dataAccessService.getList(EPApp.class,
336 " where ( enabled = 'Y' or id = " + ECOMP_APP_ID + ")", "name", null)).thenReturn(appsList);
337 List<AppsResponse> actual = epAppCommonServiceImpl.getAllApps(false);
341 public void getAppTest() {
342 EPApp expected = mockApp();
343 Mockito.when((EPApp) dataAccessService.getDomainObject(EPApp.class, expected.getId(), null))
344 .thenReturn(expected);
345 EPApp actual = epAppCommonServiceImpl.getApp(expected.getId());
346 assertEquals(expected, actual);
350 public void getAppExceptionTest() {
351 EPApp expected = mockApp();
352 Mockito.doThrow(new NullPointerException()).when(dataAccessService).getDomainObject(EPApp.class,
353 expected.getId(), null);
354 EPApp actual = epAppCommonServiceImpl.getApp(expected.getId());
358 @SuppressWarnings("unchecked")
360 public void getAppDetailTest() {
361 EPApp expected = mockApp();
362 List<EPApp> appList = new ArrayList<>();
363 appList.add(expected);
364 final Map<String, String> params = new HashMap<String, String>();
365 params.put("appName", expected.getName());
366 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getMyloginAppDetails", params, null))
367 .thenReturn(appList);
368 EPApp actual = epAppCommonServiceImpl.getAppDetail(expected.getName());
369 assertEquals(expected, actual);
373 public void getAppDetailExceptionTest() {
374 EPApp expected = mockApp();
375 List<EPApp> appList = new ArrayList<>();
376 appList.add(expected);
377 final Map<String, String> params = new HashMap<String, String>();
378 params.put("appName", expected.getName());
379 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery("getMyloginAppDetails",
381 EPApp actual = epAppCommonServiceImpl.getAppDetail(expected.getName());
386 public void getUserProfile() {
387 EPUser user = mockUser.mockEPUser();
388 final Map<String, String> params = new HashMap<>();
389 params.put("org_user_id", user.getOrgUserId());
390 List<UserRole> userRoleList = new ArrayList<>();
391 UserRole userRole = new UserRole();
392 userRole.setFirstName("GuestT");
393 userRole.setLastName("GuestT");
394 userRole.setOrgUserId("guestT");
395 userRole.setRoleId(1l);
396 userRole.setRoleName("Test");
397 userRole.setUser_Id(-1l);
398 userRoleList.add(userRole);
399 UserRoles expected = new UserRoles(userRole);
400 Mockito.when(dataAccessService.executeNamedQuery("getUserRoles", params, null)).thenReturn(userRoleList);
401 UserRoles actual = epAppCommonServiceImpl.getUserProfile(user.getOrgUserId());
402 assertEquals(expected.getOrgUserId(), actual.getOrgUserId());
406 public void getUserProfileNullTest() {
407 EPUser user = mockUser.mockEPUser();
408 final Map<String, String> params = new HashMap<>();
409 params.put("org_user_id", user.getOrgUserId());
410 List<UserRole> userRoleList = new ArrayList<>();
411 Mockito.when(dataAccessService.executeNamedQuery("getUserRoles", params, null)).thenReturn(userRoleList);
412 UserRoles actual = epAppCommonServiceImpl.getUserProfile(user.getOrgUserId());
417 public void getUserProfileNormalizedTest() {
418 EPUser user = mockUser.mockEPUser();
420 user.setLoginId("guestT");
421 final Map<String, String> params = new HashMap<>();
422 params.put("org_user_id", user.getOrgUserId());
423 List<UserRole> userRoleList = new ArrayList<>();
424 UserRole userRole = new UserRole();
425 userRole.setFirstName("GuestT");
426 userRole.setLastName("GuestT");
427 userRole.setOrgUserId("guestT");
428 userRole.setRoleId(1l);
429 userRole.setRoleName("Test");
430 userRole.setUser_Id(-1l);
431 userRoleList.add(userRole);
432 UserRoles expected = new UserRoles(userRole);
433 Mockito.when(dataAccessService.executeNamedQuery("getUserRoles", params, null)).thenReturn(userRoleList);
434 UserRoles actual = epAppCommonServiceImpl.getUserProfileNormalized(user);
435 assertEquals(expected.getOrgUserId(), actual.getOrgUserId());
439 public void getRestrictedAppRolesTest() {
440 EPUser user = mockUser.mockEPUser();
441 EPApp mockApp = mockApp();
442 mockApp.setRestrictedApp(true);
443 user.setLoginId("guestT");
444 List<LocalRole> expected = new ArrayList<>();
445 LocalRole localRole = new LocalRole();
446 localRole.setRoleId(1);
447 localRole.setRolename("test1");
448 expected.add(localRole);
449 String sql = "SELECT ROLE_ID, ROLE_NAME from FN_ROLE where UPPER(ACTIVE_YN) = 'Y' AND ROLE_ID = '"
450 + RESTRICTED_APP_ROLE_ID + "'";
451 Mockito.when(dataAccessService.executeSQLQuery(sql, LocalRole.class, null)).thenReturn(expected);
452 Mockito.when((EPApp) dataAccessService.getDomainObject(EPApp.class, mockApp.getId(), null)).thenReturn(mockApp);
453 List<LocalRole> actual = epAppCommonServiceImpl.getAppRoles(mockApp.getId());
454 assertEquals(expected, actual);
458 public void getPoralAppRolesTest() {
459 EPUser user = mockUser.mockEPUser();
460 EPApp mockApp = mockApp();
461 mockApp.setRestrictedApp(false);
463 user.setLoginId("guestT");
464 List<LocalRole> expected = new ArrayList<>();
465 LocalRole localRole = new LocalRole();
466 localRole.setRoleId(1);
467 localRole.setRolename("test1");
468 expected.add(localRole);
469 String sql = "SELECT ROLE_ID, ROLE_NAME from FN_ROLE where UPPER(ACTIVE_YN) = 'Y' AND APP_ID IS NULL";
470 Mockito.when(dataAccessService.executeSQLQuery(sql, LocalRole.class, null)).thenReturn(expected);
471 Mockito.when((EPApp) dataAccessService.getDomainObject(EPApp.class, mockApp.getId(), null)).thenReturn(mockApp);
472 List<LocalRole> actual = epAppCommonServiceImpl.getAppRoles(mockApp.getId());
473 assertEquals(expected, actual);
477 public void getNonPortalAndNonRestrictedAppRolesTest() {
478 EPUser user = mockUser.mockEPUser();
479 EPApp mockApp = mockApp();
480 mockApp.setRestrictedApp(false);
482 user.setLoginId("guestT");
483 List<LocalRole> expected = new ArrayList<>();
484 LocalRole localRole = new LocalRole();
485 localRole.setRoleId(1);
486 localRole.setRolename("test1");
487 expected.add(localRole);
488 String sql = "SELECT ROLE_ID, ROLE_NAME from FN_ROLE where UPPER(ACTIVE_YN) = 'Y' AND APP_ID = '"
489 + mockApp.getId() + "'";
490 Mockito.when(dataAccessService.executeSQLQuery(sql, LocalRole.class, null)).thenReturn(expected);
491 Mockito.when((EPApp) dataAccessService.getDomainObject(EPApp.class, mockApp.getId(), null)).thenReturn(mockApp);
492 List<LocalRole> actual = epAppCommonServiceImpl.getAppRoles(mockApp.getId());
493 assertEquals(expected, actual);
497 public void getAdminAppsTest() {
498 EPUser user = mockUser.mockEPUser();
500 List<AppIdAndNameTransportModel> expected = new ArrayList<>();
501 AppIdAndNameTransportModel appIdAndNameTransportModel = new AppIdAndNameTransportModel();
502 appIdAndNameTransportModel.setId(1l);
503 appIdAndNameTransportModel.setName("test1");
504 expected.add(appIdAndNameTransportModel);
505 Mockito.when(adminRolesServiceImpl.isAccountAdmin(user)).thenReturn(true);
506 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 "
507 + "where userrole.USER_ID = %d AND userrole.ROLE_ID=" + ACCOUNT_ADMIN_ROLE_ID
508 + " AND (app.ENABLED = 'Y' OR app.APP_ID=1)";
509 String sql = String.format(format, user.getId());
510 Mockito.when(dataAccessService.executeSQLQuery(sql, AppIdAndNameTransportModel.class, null))
511 .thenReturn(expected);
512 List<AppIdAndNameTransportModel> actual = epAppCommonServiceImpl.getAdminApps(user);
513 assertEquals(expected, actual);
517 public void getAdminAppsExceptionTest() {
518 EPUser user = mockUser.mockEPUser();
520 List<AppIdAndNameTransportModel> expected = new ArrayList<>();
521 Mockito.when(adminRolesServiceImpl.isAccountAdmin(user)).thenReturn(true);
522 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 "
523 + "where userrole.USER_ID = %d AND userrole.ROLE_ID=" + ACCOUNT_ADMIN_ROLE_ID
524 + " AND (app.ENABLED = 'Y' OR app.APP_ID=1)";
525 String sql = String.format(format, user.getId());
526 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeSQLQuery(sql,
527 AppIdAndNameTransportModel.class, null);
528 List<AppIdAndNameTransportModel> actual = epAppCommonServiceImpl.getAdminApps(user);
529 assertEquals(expected, actual);
533 @SuppressWarnings("unchecked")
535 public void addOnboardingAppUnKnownHostExceptionTest() throws Exception {
536 PowerMockito.mockStatic(PortalApiConstants.class);
537 PowerMockito.mockStatic(PortalApiProperties.class);
538 EPUser user = mockUser.mockEPUser();
539 List<EPApp> mockAppList = new ArrayList<>();
540 OnboardingApp onboardApp = new OnboardingApp();
541 onboardApp.setRestrictedApp(false);
542 onboardApp.name = "test1";
543 onboardApp.url = "http://test.com";
544 onboardApp.isOpen = false;
545 onboardApp.isEnabled = true;
546 onboardApp.username = "test123";
547 onboardApp.appPassword = "test123";
548 List<Criterion> restrictionsList = new ArrayList<Criterion>();
549 Criterion urlCrit = Restrictions.eq("url", onboardApp.url);
550 Criterion nameCrit = Restrictions.eq("name", onboardApp.name);
551 Criterion orCrit = Restrictions.or(urlCrit, nameCrit);
552 restrictionsList.add(orCrit);
553 List<String> uebList = new ArrayList<>();
554 uebList.add("localhost");
555 com.att.nsa.apiClient.credentials.ApiCredential apiCredential = new ApiCredential(user.getEmail(),
556 "ECOMP Portal Owner");
557 CambriaIdentityManager mockIm = Mockito
558 .spy(new CambriaClientBuilders.IdentityManagerBuilder().usingHosts(uebList).build());
559 Mockito.doReturn(apiCredential).when(mockIm).createApiKey(user.getEmail(), "ECOMP Portal Owner");
560 Mockito.when(PortalApiProperties.getProperty(PortalApiConstants.UEB_URL_LIST)).thenReturn("localhost");
561 Mockito.when((List<EPApp>) dataAccessService.getList(EPApp.class, null, restrictionsList, null))
562 .thenReturn(mockAppList);
563 FieldsValidator expected = new FieldsValidator();
564 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
565 FieldsValidator actual = epAppCommonServiceImpl.addOnboardingApp(onboardApp, user);
566 assertEquals(expected, actual);
569 @SuppressWarnings("unchecked")
571 public void modifyOnboardingAppTest() throws Exception {
572 EPUser user = mockUser.mockEPUser();
573 EPApp mockApp = mockApp();
574 mockApp.setName("test1");
576 mockApp.setUrl("http://test.com");
577 mockApp.setUsername("test123");
578 mockApp.setAppPassword("test123");
579 mockApp.setRestrictedApp(false);
580 mockApp.setEnabled(true);
581 mockApp.setOpen(false);
582 List<EPApp> mockAppList = new ArrayList<>();
583 mockAppList.add(mockApp);
584 OnboardingApp onboardApp = new OnboardingApp();
585 onboardApp.setRestrictedApp(false);
586 onboardApp.name = "test1";
588 onboardApp.url = "http://test.com";
589 onboardApp.restUrl = "http://test.com";
590 onboardApp.isOpen = false;
591 onboardApp.isEnabled = true;
592 onboardApp.thumbnail = "test123imgthumbnail";
593 onboardApp.username = "test123";
594 onboardApp.appPassword = "test123";
595 onboardApp.isCentralAuth=true;
596 onboardApp.myLoginsAppName="test123";
597 onboardApp.myLoginsAppOwner="test123";
598 onboardApp.nameSpace="com.test";
600 List<Criterion> restrictionsList1 = new ArrayList<Criterion>();
601 Criterion idCrit = Restrictions.eq("id", onboardApp.id);
602 Criterion urlCrit = Restrictions.eq("url", onboardApp.url);
603 Criterion nameCrit = Restrictions.eq("name", onboardApp.name);
604 Criterion orCrit = Restrictions.or(idCrit, urlCrit, nameCrit);
605 restrictionsList1.add(orCrit);
606 Mockito.when((List<EPApp>) dataAccessService.getList(EPApp.class, null, restrictionsList1, null))
607 .thenReturn(mockAppList);
608 Mockito.when((EPApp) session.get(EPApp.class, onboardApp.id)).thenReturn(mockApp);
609 String sql = "SELECT m.menu_id, m.column_num, m.text, m.parent_menu_id, m.url, m.active_yn "
610 + "FROM fn_menu_functional m, fn_menu_functional_roles r " + "WHERE m.menu_id = r.menu_id "
611 + " AND r.app_id = '" + onboardApp.id + "' ";
612 List<Integer> roles = new ArrayList<>();
615 List<FunctionalMenuItem> menuItems = new ArrayList<>();
616 FunctionalMenuItem functionalMenuItem = new FunctionalMenuItem();
617 functionalMenuItem.setRestrictedApp(false);
618 functionalMenuItem.setUrl("http://test1.com");
619 functionalMenuItem.setRoles(roles);
620 menuItems.add(functionalMenuItem);
621 Mockito.when(dataAccessService.executeSQLQuery(sql, FunctionalMenuItem.class, null)).thenReturn(menuItems);
622 Mockito.when((FunctionalMenuItem) session.get(FunctionalMenuItem.class, functionalMenuItem.menuId))
623 .thenReturn(functionalMenuItem);
624 FieldsValidator expected = new FieldsValidator();
625 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
626 FieldsValidator actual = epAppCommonServiceImpl.modifyOnboardingApp(onboardApp, user);
627 assertEquals(expected, actual);
631 public void saveWidgetsSortManualTest() {
632 EPUser user = mockUser.mockEPUser();
633 List<EPWidgetsManualSortPreference> mockEPManualWidgets = new ArrayList<>();
634 EPWidgetsManualSortPreference epWidgetsManualSortPreference = new EPWidgetsManualSortPreference();
635 epWidgetsManualSortPreference.setUserId(user.getId());
636 epWidgetsManualSortPreference.setWidgetCol(1);
637 epWidgetsManualSortPreference.setWidgetHeight(1);
638 epWidgetsManualSortPreference.setWidgetId(1l);
639 epWidgetsManualSortPreference.setWidgetRow(1);
640 epWidgetsManualSortPreference.setWidgetWidth(1);
641 mockEPManualWidgets.add(epWidgetsManualSortPreference);
642 final Map<String, Long> params = new HashMap<>();
643 params.put("userId", user.getId());
644 Mockito.when(dataAccessService.executeNamedQuery("userWidgetManualSortPrfQuery", params, null))
645 .thenReturn(mockEPManualWidgets);
646 FieldsValidator expected = new FieldsValidator();
647 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
648 List<EPWidgetsSortPreference> epWidgetsSortPreferenceList = new ArrayList<>();
649 EPWidgetsSortPreference mockEPWidgetsSortPreference = new EPWidgetsSortPreference();
650 mockEPWidgetsSortPreference.setRow(2);
651 mockEPWidgetsSortPreference.setHeaderText("test");
652 mockEPWidgetsSortPreference.setSizeX(2);
653 mockEPWidgetsSortPreference.setSizeY(2);
654 mockEPWidgetsSortPreference.setWidgetid(2l);
655 mockEPWidgetsSortPreference.setWidgetIdentifier("test");
656 mockEPWidgetsSortPreference.setCol(2);
657 epWidgetsSortPreferenceList.add(mockEPWidgetsSortPreference);
658 FieldsValidator actual = epAppCommonServiceImpl.saveWidgetsSortManual(epWidgetsSortPreferenceList, user);
659 assertEquals(expected, actual);
663 public void saveWidgetsSortManualExistingRecordTest() {
664 EPUser user = mockUser.mockEPUser();
665 List<EPWidgetsManualSortPreference> mockEPManualWidgets = new ArrayList<>();
666 EPWidgetsManualSortPreference epWidgetsManualSortPreference = new EPWidgetsManualSortPreference();
667 epWidgetsManualSortPreference.setUserId(user.getId());
668 epWidgetsManualSortPreference.setWidgetCol(1);
669 epWidgetsManualSortPreference.setWidgetHeight(1);
670 epWidgetsManualSortPreference.setWidgetId(2l);
671 epWidgetsManualSortPreference.setWidgetRow(1);
672 epWidgetsManualSortPreference.setWidgetWidth(1);
673 mockEPManualWidgets.add(epWidgetsManualSortPreference);
674 final Map<String, Long> params = new HashMap<>();
675 params.put("userId", user.getId());
676 Mockito.when(dataAccessService.executeNamedQuery("userWidgetManualSortPrfQuery", params, null))
677 .thenReturn(mockEPManualWidgets);
678 FieldsValidator expected = new FieldsValidator();
679 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
680 List<EPWidgetsSortPreference> epWidgetsSortPreferenceList = new ArrayList<>();
681 EPWidgetsSortPreference mockEPWidgetsSortPreference = new EPWidgetsSortPreference();
682 mockEPWidgetsSortPreference.setRow(2);
683 mockEPWidgetsSortPreference.setHeaderText("test");
684 mockEPWidgetsSortPreference.setSizeX(2);
685 mockEPWidgetsSortPreference.setSizeY(2);
686 mockEPWidgetsSortPreference.setWidgetid(2l);
687 mockEPWidgetsSortPreference.setWidgetIdentifier("test");
688 mockEPWidgetsSortPreference.setCol(2);
689 epWidgetsSortPreferenceList.add(mockEPWidgetsSortPreference);
690 FieldsValidator actual = epAppCommonServiceImpl.saveWidgetsSortManual(epWidgetsSortPreferenceList, user);
691 assertEquals(expected, actual);
695 public void deleteUserWidgetSortPrefTest() {
696 EPUser user = mockUser.mockEPUser();
697 List<EPWidgetsManualSortPreference> mockEPManualWidgets = new ArrayList<>();
698 EPWidgetsManualSortPreference epWidgetsManualSortPreference = new EPWidgetsManualSortPreference();
699 epWidgetsManualSortPreference.setUserId(user.getId());
700 epWidgetsManualSortPreference.setWidgetCol(1);
701 epWidgetsManualSortPreference.setWidgetHeight(1);
702 epWidgetsManualSortPreference.setWidgetId(2l);
703 epWidgetsManualSortPreference.setWidgetRow(1);
704 epWidgetsManualSortPreference.setWidgetWidth(1);
705 mockEPManualWidgets.add(epWidgetsManualSortPreference);
706 final Map<String, Long> params = new HashMap<>();
707 params.put("userId", user.getId());
708 Mockito.when(dataAccessService.executeNamedQuery("userWidgetManualSortPrfQuery", params, null))
709 .thenReturn(mockEPManualWidgets);
710 FieldsValidator expected = new FieldsValidator();
711 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
712 List<EPWidgetsSortPreference> epWidgetsSortPreferenceList = new ArrayList<>();
713 EPWidgetsSortPreference mockEPWidgetsSortPreference = new EPWidgetsSortPreference();
714 mockEPWidgetsSortPreference.setRow(2);
715 mockEPWidgetsSortPreference.setHeaderText("test");
716 mockEPWidgetsSortPreference.setSizeX(2);
717 mockEPWidgetsSortPreference.setSizeY(2);
718 mockEPWidgetsSortPreference.setWidgetid(2l);
719 mockEPWidgetsSortPreference.setWidgetIdentifier("test");
720 mockEPWidgetsSortPreference.setCol(2);
721 epWidgetsSortPreferenceList.add(mockEPWidgetsSortPreference);
722 FieldsValidator actual = epAppCommonServiceImpl.deleteUserWidgetSortPref(epWidgetsSortPreferenceList, user);
723 assertEquals(expected, actual);
727 public void saveAppsSortPreferenceForNewUserTest() {
728 EPUser user = mockUser.mockEPUser();
729 List<EPUserAppsSortPreference> mockEPAppSortPrefList = new ArrayList<>();
730 final Map<String, Long> params = new HashMap<>();
731 params.put("userId", user.getId());
732 Mockito.when(dataAccessService.executeNamedQuery("userAppsSortPreferenceQuery", params, null))
733 .thenReturn(mockEPAppSortPrefList);
734 FieldsValidator expected = new FieldsValidator();
735 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
736 EPAppsSortPreference mockEPAppsSortPreference = new EPAppsSortPreference();
737 mockEPAppsSortPreference.setIndex(1);
738 mockEPAppsSortPreference.setTitle("Last Used");
739 mockEPAppsSortPreference.setValue("L");
740 FieldsValidator actual = epAppCommonServiceImpl.saveAppsSortPreference(mockEPAppsSortPreference, user);
741 assertEquals(expected, actual);
745 public void saveAppsSortPreferenceUpdateTest() {
746 EPUser user = mockUser.mockEPUser();
747 List<EPUserAppsSortPreference> mockEPAppSortPrefList = new ArrayList<>();
748 EPUserAppsSortPreference mockEPAppSortPref = new EPUserAppsSortPreference();
749 mockEPAppSortPref.setSortPref("L");
750 mockEPAppSortPref.setId(2l);
751 mockEPAppSortPref.setUserId((int) (long) user.getId());
752 mockEPAppSortPrefList.add(mockEPAppSortPref);
753 final Map<String, Long> params = new HashMap<>();
754 params.put("userId", user.getId());
755 Mockito.when(dataAccessService.executeNamedQuery("userAppsSortPreferenceQuery", params, null))
756 .thenReturn(mockEPAppSortPrefList);
757 FieldsValidator expected = new FieldsValidator();
758 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
759 EPAppsSortPreference mockEPAppsSortPreference = new EPAppsSortPreference();
760 mockEPAppsSortPreference.setIndex(1);
761 mockEPAppsSortPreference.setTitle("Last Used");
762 mockEPAppsSortPreference.setValue("L");
763 FieldsValidator actual = epAppCommonServiceImpl.saveAppsSortPreference(mockEPAppsSortPreference, user);
764 assertEquals(expected, actual);
768 public void saveAppsSortPreferenceExceptionTest() {
769 EPUser user = mockUser.mockEPUser();
770 final Map<String, Long> params = new HashMap<>();
771 params.put("userId", user.getId());
772 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
773 FieldsValidator expected = new FieldsValidator();
774 expected.setHttpStatusCode(500l);
775 //expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
776 EPAppsSortPreference mockEPAppsSortPreference = new EPAppsSortPreference();
777 mockEPAppsSortPreference.setIndex(1);
778 mockEPAppsSortPreference.setTitle("Last Used");
779 mockEPAppsSortPreference.setValue("L");
780 FieldsValidator actual = epAppCommonServiceImpl.saveAppsSortPreference(mockEPAppsSortPreference, user);
781 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
785 public void getUserAppsSortTypePreferenceTest() {
786 EPUser user = mockUser.mockEPUser();
787 final Map<String, Long> params = new HashMap<>();
788 List<EPUserAppsSortPreference> mockEPAppSortPrefList = new ArrayList<>();
789 EPUserAppsSortPreference mockEPAppSortPref = new EPUserAppsSortPreference();
790 mockEPAppSortPref.setSortPref("L");
791 mockEPAppSortPref.setId(2l);
792 mockEPAppSortPref.setUserId((int) (long) user.getId());
793 mockEPAppSortPrefList.add(mockEPAppSortPref);
794 params.put("userId", user.getId());
795 Mockito.when(dataAccessService.executeNamedQuery("userAppsSortPreferenceQuery", params, null))
796 .thenReturn(mockEPAppSortPrefList);
797 String actual = epAppCommonServiceImpl.getUserAppsSortTypePreference(user);
798 assertEquals(mockEPAppSortPref.getSortPref(), actual);
802 public void getUserAppsSortTypePreferenceExceptionTest() {
803 EPUser user = mockUser.mockEPUser();
804 final Map<String, Long> params = new HashMap<>();
805 List<EPUserAppsSortPreference> mockEPAppSortPrefList = new ArrayList<>();
806 EPUserAppsSortPreference mockEPAppSortPref = new EPUserAppsSortPreference();
807 mockEPAppSortPref.setSortPref("L");
808 mockEPAppSortPref.setId(2l);
809 mockEPAppSortPref.setUserId((int) (long) user.getId());
810 mockEPAppSortPrefList.add(mockEPAppSortPref);
811 params.put("userId", user.getId());
812 Mockito.doThrow(new NullPointerException()).when(dataAccessService)
813 .executeNamedQuery("userAppsSortPreferenceQuery", params, null);
814 String actual = epAppCommonServiceImpl.getUserAppsSortTypePreference(user);
819 public void deleteUserAppSortManualTest() {
820 EPUser user = mockUser.mockEPUser();
821 EPApp mockApp = mockApp();
823 final Map<String, Long> params = new HashMap<>();
824 List<EPUserAppsManualSortPreference> epManualApps = new ArrayList<EPUserAppsManualSortPreference>();
825 EPUserAppsManualSortPreference epManualApp = new EPUserAppsManualSortPreference();
826 epManualApp.setAppId(mockApp.getId());
827 epManualApp.setAppManualSortOrder(1);
828 epManualApp.setId(1l);
829 epManualApp.setUserId(user.getId());
830 epManualApps.add(epManualApp);
831 params.put("userId", user.getId());
832 Mockito.when(dataAccessService.executeNamedQuery("userAppsManualSortPrfQuery", params, null)).thenReturn(epManualApps);
833 EPDeleteAppsManualSortPref delAppSortManual = new EPDeleteAppsManualSortPref();
834 delAppSortManual.setAppId(mockApp.getId());
835 delAppSortManual.setPending(false);
836 delAppSortManual.setSelect(false);
837 FieldsValidator actual = epAppCommonServiceImpl.deleteUserAppSortManual(delAppSortManual, user);
838 FieldsValidator expected = new FieldsValidator();
839 expected.setHttpStatusCode(200l);
840 assertEquals(expected, actual);
844 public void deleteUserAppSortManualExceptionTest() {
845 EPUser user = mockUser.mockEPUser();
846 EPApp mockApp = mockApp();
848 final Map<String, Long> params = new HashMap<>();
849 List<EPUserAppsManualSortPreference> epManualApps = new ArrayList<EPUserAppsManualSortPreference>();
850 EPUserAppsManualSortPreference epManualApp = new EPUserAppsManualSortPreference();
851 epManualApp.setAppId(mockApp.getId());
852 epManualApp.setAppManualSortOrder(1);
853 epManualApp.setId(1l);
854 epManualApp.setUserId(user.getId());
855 epManualApps.add(epManualApp);
856 params.put("userId", user.getId());
857 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery("userAppsManualSortPrfQuery", params, null);
858 EPDeleteAppsManualSortPref delAppSortManual = new EPDeleteAppsManualSortPref();
859 delAppSortManual.setAppId(mockApp.getId());
860 delAppSortManual.setPending(false);
861 delAppSortManual.setSelect(false);
862 FieldsValidator actual = epAppCommonServiceImpl.deleteUserAppSortManual(delAppSortManual, user);
863 FieldsValidator expected = new FieldsValidator();
864 expected.setHttpStatusCode(500l);
865 assertEquals(expected, actual);
868 @SuppressWarnings("unchecked")
870 public void getAppDetailByAppNameTest(){
871 String appName = "test";
872 EPApp expectedResult = mockApp();
873 List<EPApp> appList = new ArrayList<>();
874 appList.add(expectedResult);
875 final Map<String, String> params = new HashMap<String, String>();
876 params.put("appName", expectedResult.getName());
877 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAppDetailsByAppName", params, null))
878 .thenReturn(appList);
879 EPApp actualResult = epAppCommonServiceImpl.getAppDetailByAppName(appName);
880 assertEquals(expectedResult, actualResult);
883 @SuppressWarnings("unchecked")
885 public void getAppDetailByAppNameExceptionTest(){
886 String appName = null;
887 EPApp expectedResult = null;
888 List<EPApp> appList = new ArrayList<>();
889 appList.add(expectedResult);
890 final Map<String, String> params = new HashMap<String, String>();
891 params.put("appName", null);
892 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAppDetailsByAppName", params, null))
893 .thenReturn(appList);
894 EPApp actualResult = epAppCommonServiceImpl.getAppDetailByAppName(appName);
895 assertEquals(expectedResult, actualResult);
898 @SuppressWarnings("unchecked")
900 public void getAppsForSuperAdminAndAccountAdminTest(){
901 String sql = "SELECT app.APP_ID, app.APP_NAME, app.APP_TYPE FROM FN_APP app "
902 + "where app.ENABLED = 'Y' AND app.app_type = 1";
903 EPUser user = mockUser.mockEPUser();
904 List<AppIdAndNameTransportModel> expected = null;
905 Mockito.when(adminRolesServiceImpl.isSuperAdmin(user)).thenReturn(true);
906 Mockito.when(adminRolesServiceImpl.isAccountAdmin(user)).thenReturn(true);
907 List<AppIdAndNameTransportModel> actual = null;
908 Mockito.when((List<AppIdAndNameTransportModel>) dataAccessService.executeSQLQuery(sql, AppIdAndNameTransportModel.class, null))
910 actual = epAppCommonServiceImpl.getAppsForSuperAdminAndAccountAdmin(user);
911 assertEquals(expected, actual);
914 @SuppressWarnings("unchecked")
916 public void getAppsForSuperAdminAndNotAccountAdminTest(){
917 String sql = "SELECT app.APP_ID, app.APP_NAME, app.APP_TYPE FROM FN_APP app "
918 + "where app.ENABLED = 'Y' AND app.app_type = 1";
919 EPUser user = mockUser.mockEPUser();
920 List<AppIdAndNameTransportModel> expected = new ArrayList<AppIdAndNameTransportModel>();
921 Mockito.when(adminRolesServiceImpl.isSuperAdmin(user)).thenReturn(false);
922 Mockito.when(adminRolesServiceImpl.isAccountAdmin(user)).thenReturn(true);
923 List<AppIdAndNameTransportModel> actual = null;
924 Mockito.when((List<AppIdAndNameTransportModel>) dataAccessService.executeSQLQuery(sql, AppIdAndNameTransportModel.class, null))
926 actual = epAppCommonServiceImpl.getAppsForSuperAdminAndAccountAdmin(user);
927 assertEquals(expected, actual);
930 @SuppressWarnings("unchecked")
932 public void getAppsForAdminAndAccountAdminTest(){
933 String sql = "SELECT app.APP_ID, app.APP_NAME, app.APP_TYPE FROM FN_APP app "
934 + "where app.ENABLED = 'Y' AND app.app_type = 1";
935 EPUser user = mockUser.mockEPUser();
936 List<AppIdAndNameTransportModel> expected = null;
937 Mockito.when(adminRolesServiceImpl.isSuperAdmin(user)).thenReturn(true);
938 List<AppIdAndNameTransportModel> actual = null;
939 Mockito.when((List<AppIdAndNameTransportModel>) dataAccessService.executeSQLQuery(sql, AppIdAndNameTransportModel.class, null))
941 actual = epAppCommonServiceImpl.getAppsForSuperAdminAndAccountAdmin(user);
942 assertEquals(expected, actual);
946 public void getAppsForSuperAdminAndAccountAdminExceptionTest(){
947 String sql = "SELECT app.APP_ID, app.APP_NAME, app.APP_TYPE FROM FN_APP app "
948 + "where app.ENABLED = 'Y' AND app.app_type = 1";
949 EPUser user = mockUser.mockEPUser();
950 List<AppIdAndNameTransportModel> expected = new ArrayList<AppIdAndNameTransportModel>();
951 Mockito.when(adminRolesServiceImpl.isSuperAdmin(user)).thenReturn(true);
952 List<AppIdAndNameTransportModel> actual = null;
953 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeSQLQuery(sql, AppIdAndNameTransportModel.class, null);
954 actual = epAppCommonServiceImpl.getAppsForSuperAdminAndAccountAdmin(user);
955 assertEquals(expected, actual);
959 public void getDataAccessServiceTest(){
960 assertEquals(epAppCommonServiceImpl.getDataAccessService(), epAppCommonServiceImpl.getDataAccessService());
963 @SuppressWarnings("unchecked")
965 public void getAppsAdminsTest(){
966 List<AdminUserApplications> expected = new ArrayList<AdminUserApplications>();
967 List<AdminUserApplications> actual = null;
968 List<AdminUserApp> list = new ArrayList<AdminUserApp>();
969 Map<String, String> params = new HashMap<>();
970 params.put("accountAdminRoleId", ACCOUNT_ADMIN_ROLE_ID);
971 Mockito.when((List<AdminUserApp>) dataAccessService.executeNamedQuery("getAppsAdmins", params, null)).thenReturn(list);
972 actual = epAppCommonServiceImpl.getAppsAdmins();
973 assertEquals(expected, actual);
977 public void getAppsAdminsExceptionTest(){
978 List<AdminUserApplications> expected = null;
979 List<AdminUserApplications> actual = null;
980 Map<String, String> params = new HashMap<>();
981 params.put("accountAdminRoleId", ACCOUNT_ADMIN_ROLE_ID);
982 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery("getAppsAdmins", params, null);
983 actual = epAppCommonServiceImpl.getAppsAdmins();
984 assertEquals(expected, actual);
987 @SuppressWarnings("unchecked")
989 public void getAppsAdminsAggregateResultsTest(){
990 List<AdminUserApplications> expected = new ArrayList<AdminUserApplications>();
991 AdminUserApp adminUserApp = new AdminUserApp();
992 AdminUserApplications adminUserApplications = new AdminUserApplications(adminUserApp);
993 expected.add(adminUserApplications);
994 List<AdminUserApplications> actual = null;
995 List<AdminUserApp> list = new ArrayList<AdminUserApp>();
996 AdminUserApp adminUserApp1 = new AdminUserApp();
997 list.add(adminUserApp1);
998 Map<String, String> params = new HashMap<>();
999 params.put("accountAdminRoleId", ACCOUNT_ADMIN_ROLE_ID);
1000 Mockito.when((List<AdminUserApp>) dataAccessService.executeNamedQuery("getAppsAdmins", params, null)).thenReturn(list);
1001 actual = epAppCommonServiceImpl.getAppsAdmins();
1002 assertEquals(expected.size(), actual.size());
1005 @SuppressWarnings("unchecked")
1007 public void getUserAppsTest(){
1009 EPApp epApp = new EPApp();
1010 epApp.setOpen(false);
1011 List<EPApp> expected = new ArrayList<EPApp>();
1012 List<EPApp> list = new ArrayList<EPApp>();
1013 EPUser epUser = new EPUser();
1015 Mockito.when((List<EPApp>) dataAccessService.executeSQLQuery(sql, EPApp.class, null)).thenReturn(list);
1016 List<EPApp> actual = epAppCommonServiceImpl.getUserApps(epUser);
1017 assertEquals(expected.size(), actual.size());
1020 @SuppressWarnings("unchecked")
1022 public void getUserAppsUserGuestTest(){
1024 List<EPApp> expected = new ArrayList<EPApp>();
1025 List<EPApp> list = new ArrayList<EPApp>();
1026 EPUser epUser = new EPUser();
1027 epUser.setGuest(true);
1028 Mockito.when((List<EPApp>) dataAccessService.executeSQLQuery(sql, EPApp.class, null)).thenReturn(list);
1029 List<EPApp> actual = epAppCommonServiceImpl.getUserApps(epUser);
1030 assertEquals(expected.size(), actual.size());
1033 @SuppressWarnings("unchecked")
1035 public void getPersAdminAppsTest(){
1036 List<EPApp> expected = new ArrayList<EPApp>();
1037 final Map<String, Long> params = new HashMap<>();
1038 params.put("userId", (long)123);
1039 EPUser epUser = new EPUser();
1040 List<EPApp> list = new ArrayList<EPApp>();
1041 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getPersAdminApps", params, null)).thenReturn(list);
1042 List<EPApp> actual = epAppCommonServiceImpl.getPersAdminApps(epUser);
1043 assertEquals(expected, actual);
1046 @SuppressWarnings("unchecked")
1048 public void getPersUserAppsTest(){
1049 List<EPApp> expected = new ArrayList<EPApp>();
1050 EPUser epUser = new EPUser();
1051 final Map<String, Long> params = new HashMap<>();
1052 params.put("userId", (long)123);
1053 List<EPApp> list = new ArrayList<EPApp>();
1054 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getPersUserApps", params, null)).thenReturn(list);
1055 List<EPApp> actual = epAppCommonServiceImpl.getPersUserApps(epUser);
1056 assertEquals(expected, actual);
1059 @SuppressWarnings("unchecked")
1061 public void getUserAppCatalogTest(){
1062 List<AppCatalogItem> expected = new ArrayList<AppCatalogItem>();
1063 EPUser epUser = new EPUser();
1064 final Map<String, Long> params = new HashMap<>();
1065 params.put("userId", (long)123);
1066 List<AppCatalogItem> list = new ArrayList<AppCatalogItem>();
1067 Mockito.when((List<AppCatalogItem>) dataAccessService.executeNamedQuery("getUserAppCatalog", params, null)).thenReturn(list);
1068 List<AppCatalogItem> actual = epAppCommonServiceImpl.getUserAppCatalog(epUser);
1069 assertEquals(expected, actual);
1072 @SuppressWarnings("unchecked")
1074 public void getAdminAppCatalogTest(){
1075 List<AppCatalogItem> expected = new ArrayList<AppCatalogItem>();
1076 EPUser epUser = new EPUser();
1077 final Map<String, Long> params = new HashMap<>();
1078 params.put("userId", (long)123);
1079 List<AppCatalogItem> list = new ArrayList<AppCatalogItem>();
1080 Mockito.when((List<AppCatalogItem>) dataAccessService.executeNamedQuery("getAdminAppCatalog", params, null)).thenReturn(list);
1081 List<AppCatalogItem> actual = epAppCommonServiceImpl.getAdminAppCatalog(epUser);
1082 assertEquals(expected, actual);
1085 @SuppressWarnings("unchecked")
1087 public void getAppsOrderByNameTest(){
1088 List<EPApp> expected = new ArrayList<EPApp>();
1089 EPUser epUser = new EPUser();
1090 List<EPApp> list = new ArrayList<EPApp>();
1091 final Map<String, Long> params = new HashMap<>();
1092 params.put("userId", (long)123);
1093 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1094 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getPersAdminAppsOrderByName", params, null)).thenReturn(list);
1095 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByName(epUser);
1096 assertEquals(expected, actual);
1099 @SuppressWarnings("unchecked")
1101 public void getAppsOrderByNameNotSuperAdminTest(){
1102 List<EPApp> expected = new ArrayList<EPApp>();
1103 EPUser epUser = new EPUser();
1104 List<EPApp> list = new ArrayList<EPApp>();
1105 final Map<String, Long> params = new HashMap<>();
1106 params.put("userId", (long)123);
1107 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(false);
1108 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getPersAdminAppsOrderByName", params, null)).thenReturn(list);
1109 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByName(epUser);
1110 assertEquals(expected, actual);
1114 public void getAppsOrderByNameExceptionTest(){
1115 List<EPApp> expected = null;
1116 EPUser epUser = new EPUser();
1117 final Map<String, Long> params = new HashMap<>();
1118 params.put("userId", null);
1119 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1120 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
1121 //Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap())).thenReturn(list);
1122 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByName(epUser);
1123 assertEquals(expected, actual);
1126 @SuppressWarnings("unchecked")
1128 public void getAppsOrderByLastUsedTest(){
1129 List<EPApp> expected = new ArrayList<EPApp>();
1130 EPUser epUser = new EPUser();
1131 List<EPApp> list = new ArrayList<EPApp>();
1132 final Map<String, Long> params = new HashMap<>();
1133 params.put("userId", (long)123);
1134 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1135 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAdminAppsOrderByLastUsed", params, null)).thenReturn(list);
1136 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByLastUsed(epUser);
1137 assertEquals(expected, actual);
1140 @SuppressWarnings("unchecked")
1142 public void getAppsOrderByLastUsedNotSuperAdminTest(){
1143 List<EPApp> expected = new ArrayList<EPApp>();
1144 EPUser epUser = new EPUser();
1145 List<EPApp> list = new ArrayList<EPApp>();
1146 final Map<String, Long> params = new HashMap<>();
1147 params.put("userId", (long)123);
1148 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(false);
1149 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAdminAppsOrderByLastUsed", params, null)).thenReturn(list);
1150 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByLastUsed(epUser);
1151 assertEquals(expected, actual);
1155 public void getAppsOrderByLastUsedExceptionTest(){
1156 List<EPApp> expected = new ArrayList<EPApp>();
1157 EPUser epUser = new EPUser();
1158 final Map<String, Long> params = new HashMap<>();
1159 params.put("userId", null);
1160 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
1161 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByLastUsed(epUser);
1162 assertEquals(expected, actual);
1165 @SuppressWarnings("unchecked")
1167 public void getAppsOrderByMostUsedTest(){
1168 List<EPApp> expected = new ArrayList<EPApp>();
1169 EPUser epUser = new EPUser();
1170 List<EPApp> list = new ArrayList<EPApp>();
1171 final Map<String, Long> params = new HashMap<>();
1172 params.put("userId", (long)123);
1173 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1174 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAppsOrderByMostUsed", params, null)).thenReturn(list);
1175 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByMostUsed(epUser);
1176 assertEquals(expected, actual);
1179 @SuppressWarnings("unchecked")
1181 public void getAppsOrderByMostUsedNotSuperAdminTest(){
1182 List<EPApp> expected = new ArrayList<EPApp>();
1183 EPUser epUser = new EPUser();
1184 List<EPApp> list = new ArrayList<EPApp>();
1185 final Map<String, Long> params = new HashMap<>();
1186 params.put("userId", (long)123);
1187 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(false);
1188 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAppsOrderByMostUsed", params, null)).thenReturn(list);
1189 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByMostUsed(epUser);
1190 assertEquals(expected, actual);
1194 public void getAppsOrderByMostUsedExceptionTest(){
1195 List<EPApp> expected = new ArrayList<EPApp>();
1196 EPUser epUser = new EPUser();
1197 final Map<String, Long> params = new HashMap<>();
1198 params.put("userId", null);
1199 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
1200 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByMostUsed(epUser);
1201 assertEquals(expected, actual);
1204 @SuppressWarnings("unchecked")
1206 public void getAppsOrderByManualTest(){
1207 List<EPApp> expected = new ArrayList<EPApp>();
1208 EPUser epUser = new EPUser();
1209 List<EPApp> list = new ArrayList<EPApp>();
1210 final Map<String, Long> params = new HashMap<>();
1211 params.put("userId", (long)123);
1212 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1213 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAdminAppsOrderByManual", params, null)).thenReturn(list);
1214 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByManual(epUser);
1215 assertEquals(expected, actual);
1218 @SuppressWarnings("unchecked")
1220 public void getAppsOrderByManualSuperAdminTest(){
1221 List<EPApp> expected = new ArrayList<EPApp>();
1222 EPUser epUser = new EPUser();
1223 List<EPApp> list = new ArrayList<EPApp>();
1224 final Map<String, Long> params = new HashMap<>();
1225 params.put("userId", (long)123);
1226 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(false);
1227 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAdminAppsOrderByManual", params, null)).thenReturn(list);
1228 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByManual(epUser);
1229 assertEquals(expected, actual);
1232 @SuppressWarnings("unchecked")
1234 public void getAppsOrderByManualExceptionTest(){
1235 List<EPApp> expected = new ArrayList<EPApp>();
1236 EPUser epUser = new EPUser();
1237 List<EPApp> list = new ArrayList<EPApp>();
1238 final Map<String, Long> params = new HashMap<>();
1239 params.put("userId", null);
1240 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1241 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
1242 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByManual(epUser);
1243 assertEquals(expected, actual);
1246 @SuppressWarnings("deprecation")
1248 public void getOnboardingAppsTest(){
1249 List<EPApp> apps = new ArrayList<EPApp>();
1250 List<OnboardingApp> expected = new ArrayList<OnboardingApp>();
1251 Mockito.when(dataAccessService.getList(EPApp.class, " where id!=" + ECOMP_APP_ID, null, null)).thenReturn(apps);
1252 List<OnboardingApp> actual = epAppCommonServiceImpl.getOnboardingApps();
1253 assertEquals(expected, actual);
1257 public void getEnabledNonOpenOnboardingAppsTest(){
1258 List<OnboardingApp> expected = new ArrayList<OnboardingApp>();
1259 List<OnboardingApp> actual = epAppCommonServiceImpl.getEnabledNonOpenOnboardingApps();
1260 assertEquals(expected, actual);
1264 public void addOnboardingAppTest(){
1265 FieldsValidator expected = new FieldsValidator();
1266 expected.setHttpStatusCode(400l);
1267 EPUser epUser = new EPUser();
1268 OnboardingApp onboardingApp = new OnboardingApp();
1270 onboardingApp.setRestrictedApp(true);
1271 onboardingApp.isCentralAuth=false;
1272 onboardingApp.isEnabled= true;
1273 FieldsValidator actual = epAppCommonServiceImpl.addOnboardingApp(onboardingApp, epUser);
1274 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
1278 public void deleteOnboardingAppTest(){
1279 FieldsValidator expected = new FieldsValidator();
1280 expected.setHttpStatusCode(403l);
1281 EPUser epUser = new EPUser();
1282 Long appId = (long) 123;
1283 OnboardingApp onboardingApp = new OnboardingApp();
1284 onboardingApp.setRestrictedApp(true);
1285 FieldsValidator actual = epAppCommonServiceImpl.deleteOnboardingApp(epUser, appId);
1286 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
1289 @SuppressWarnings("unchecked")
1291 public void deleteOnboardingAppSuperAdminTest(){
1292 FieldsValidator expected = new FieldsValidator();
1293 expected.setHttpStatusCode(200l);
1294 EPUser epUser = new EPUser();
1295 Long appId = (long) 123;
1296 OnboardingApp onboardingApp = new OnboardingApp();
1297 onboardingApp.setRestrictedApp(true);
1298 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1299 final Map<String, Long> params = new HashMap<>();
1300 params.put("app_id", (long)123);
1301 EPUserAppRolesRequest epUserAppRolesRequest = new EPUserAppRolesRequest();
1302 epUserAppRolesRequest.setUserId((long)123);
1303 List<EPUserAppRolesRequest> list= new ArrayList<>();
1304 list.add(epUserAppRolesRequest);
1305 Mockito.when((List<EPUserAppRolesRequest>) dataAccessService.executeNamedQuery("getRequestIdsForApp", params, null)).thenReturn(list);
1306 FieldsValidator actual = epAppCommonServiceImpl.deleteOnboardingApp(epUser, appId);
1307 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
1310 @Test(expected=NullPointerException.class)
1311 public void deleteOnboardingAppExceptionTest(){
1312 FieldsValidator expected = new FieldsValidator();
1313 expected.setHttpStatusCode(200l);
1314 EPUser epUser = new EPUser();
1315 //Long appId = (long) 123;
1316 List<EPUserAppRolesRequest> epUserAppRolesRequestList= new ArrayList<>();
1317 OnboardingApp onboardingApp = new OnboardingApp();
1318 onboardingApp.setRestrictedApp(true);
1319 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1320 final Map<String, Long> params = new HashMap<>();
1321 params.put("app_id", null);
1322 Mockito.when(dataAccessService.executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap())).thenThrow(nullPointerException);
1323 Mockito.when(dataAccessService.executeNamedQuery( "getRequestIdsForApp", params, null)).thenReturn(epUserAppRolesRequestList);
1324 //Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
1325 FieldsValidator actual = epAppCommonServiceImpl.deleteOnboardingApp(epUser, null);
1326 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
1329 @SuppressWarnings("unchecked")
1331 public void saveAppsSortManualAppIdNullTest(){
1332 List<EPUserAppsManualSortPreference> epUserAppsManualSortPreferenceList = new ArrayList<EPUserAppsManualSortPreference>();
1333 EPAppsManualPreference epAppsManualPreference = new EPAppsManualPreference();
1334 epAppsManualPreference.setAddRemoveApps(true);
1335 epAppsManualPreference.setAppid((long)123);
1336 FieldsValidator expected = new FieldsValidator();
1337 expected.setHttpStatusCode(200l);
1338 final Map<String, Long> params = new HashMap<>();
1339 params.put("userId", (long)123);
1340 EPUser epUser = new EPUser();
1341 List<EPAppsManualPreference> list = new ArrayList<EPAppsManualPreference>();
1342 list.add(epAppsManualPreference);
1343 Mockito.when(dataAccessService.executeNamedQuery("userAppsManualSortPrfQuery", params, null)).thenReturn(epUserAppsManualSortPreferenceList);
1344 FieldsValidator actual = epAppCommonServiceImpl.saveAppsSortManual(list, epUser);
1345 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
1349 public void saveAppsSortManualExceptionTest(){
1350 FieldsValidator expected = new FieldsValidator();
1351 expected.setHttpStatusCode(500l);
1352 final Map<String, Long> params = new HashMap<>();
1353 params.put("userId", (long)123);
1354 EPUser epUser = new EPUser();
1355 List<EPAppsManualPreference> list = new ArrayList<EPAppsManualPreference>();
1356 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
1357 FieldsValidator actual = epAppCommonServiceImpl.saveAppsSortManual(list, epUser);
1358 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
1362 public void getUserProfileForLeftMenuNullListTest(){
1363 UserRole userRole =new UserRole();
1364 userRole.setFirstName("test");
1365 UserRoles expected = null;
1366 UserRoles actual = epAppCommonServiceImpl.getUserProfileForLeftMenu("123");
1367 assertEquals(expected, actual);
1371 public void getUserProfileForLeftMenuTest(){
1372 final Map<String, String> params = new HashMap<>();
1373 params.put("org_user_id", "test");
1374 UserRole userRole =new UserRole();
1375 userRole.setFirstName("test");
1376 UserRoles expected = null;
1377 List<UserRole> list = new ArrayList<UserRole>();
1379 Mockito.when(dataAccessService.executeNamedQuery( "getUserRolesForLeftMenu", params, null)).thenReturn(list);
1380 UserRoles actual = epAppCommonServiceImpl.getUserProfileForLeftMenu("123");
1381 assertEquals(expected, actual);
1385 public void getUserProfileForRolesLeftMenuNullListTest(){
1386 UserRoles expected = null;
1387 List<UserRole> userRoleList = new ArrayList<UserRole>();
1388 final Map<String, String> params = new HashMap<>();
1389 params.put("org_user_id", "test");
1390 Mockito.when(dataAccessService.executeNamedQuery( "getRolesForLeftMenu", params, null)).thenReturn(userRoleList);
1391 UserRoles actual = epAppCommonServiceImpl.getUserProfileForRolesLeftMenu("test");
1392 assertEquals(expected, actual);
1396 public void getUserProfileForRolesLeftMenuTest(){
1397 UserRole userRole = new UserRole();
1398 userRole.setRoleId((long)123);
1399 userRole.setOrgUserId("test");
1400 userRole.setUser_Id((long)1);
1401 List<UserRole> userRoleList = new ArrayList<UserRole>();
1402 userRoleList.add(userRole);
1403 UserRoles expected = new UserRoles(userRole);
1404 final Map<String, String> params = new HashMap<>();
1405 params.put("org_user_id", "test");
1406 Mockito.when(dataAccessService.executeNamedQuery( "getRolesForLeftMenu", params, null)).thenReturn(userRoleList);
1407 UserRoles actual = epAppCommonServiceImpl.getUserProfileForRolesLeftMenu("test");
1408 assertEquals(expected.getOrgUserId(), actual.getOrgUserId());
1412 public void getUserProfileNormalizedForLeftMenuNullListTest(){
1413 EPUser epUser = new EPUser();
1414 List<String> list = new ArrayList<String>();
1416 UserRole userRole = new UserRole();
1417 userRole.setFirstName("GuestT");
1418 userRole.setLastName("GuestT");
1419 userRole.setOrgUserId("guestT");
1420 userRole.setRoleId(1l);
1421 userRole.setRoleName("Test");
1422 userRole.setUser_Id(-1l);
1423 UserRoles expected = new UserRoles(userRole);
1424 expected.setRoles(list);
1425 UserRoles actual = epAppCommonServiceImpl.getUserProfileNormalizedForLeftMenu(epUser);
1426 assertEquals(expected.getRoles(), actual.getRoles());
1430 public void getUserProfileNormalizedForRolesLeftMenuTest(){
1431 EPUser epUser = new EPUser();
1432 List<String> list = new ArrayList<String>();
1434 UserRole userRole = new UserRole();
1435 userRole.setFirstName("GuestT");
1436 userRole.setLastName("GuestT");
1437 userRole.setOrgUserId("guestT");
1438 userRole.setRoleId(1l);
1439 userRole.setRoleName("Test");
1440 userRole.setUser_Id(-1l);
1441 UserRoles expected = new UserRoles(userRole);
1442 expected.setRoles(list);
1443 UserRoles actual = epAppCommonServiceImpl.getUserProfileNormalizedForRolesLeftMenu(epUser);
1444 assertEquals(expected.getRoles(), actual.getRoles());
1447 @Test(expected = Exception.class)
1448 public void checkIfNameSpaceIsValidTest() throws Exception
1450 JSONObject mockJsonObject = new JSONObject();
1451 PowerMockito.mockStatic(EcompPortalUtils.class);
1452 ResponseEntity<String> getResponse = new ResponseEntity<>(HttpStatus.OK);
1453 Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET),
1454 Matchers.<HttpEntity<String>>any(), Matchers.eq(String.class))).thenReturn(getResponse);
1455 epAppCommonServiceImpl.checkIfNameSpaceIsValid("com.test");
1459 public void getAdminAppsOfUserTest()
1461 EPUser user = new EPUser();
1462 user.setId((long) 1);
1463 List<Integer> userAdminApps = new ArrayList<>();
1464 EPApp mockApp = mockApp();
1465 EPApp mockApp2 = mockApp();
1467 List<EPApp> appsList = new ArrayList<>();
1468 appsList.add(mockApp);
1469 appsList.add(mockApp2);
1470 Mockito.when((List<EPApp>) dataAccessService.getList(EPApp.class, " where id != " + ECOMP_APP_ID, "name", null))
1471 .thenReturn(appsList);
1472 Mockito.when(dataAccessService.executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap()))
1473 .thenReturn(userAdminApps);
1474 List<OnboardingApp> list = epAppCommonServiceImpl.getAdminAppsOfUser(user);
1475 assertEquals(list.size(), 0);