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.EpAppType;
78 import org.onap.portalapp.portal.domain.UserRole;
79 import org.onap.portalapp.portal.domain.UserRoles;
80 import org.onap.portalapp.portal.ecomp.model.AppCatalogItem;
81 import org.onap.portalapp.portal.transport.EPAppsManualPreference;
82 import org.onap.portalapp.portal.transport.EPAppsSortPreference;
83 import org.onap.portalapp.portal.transport.EPDeleteAppsManualSortPref;
84 import org.onap.portalapp.portal.transport.EPWidgetsSortPreference;
85 import org.onap.portalapp.portal.transport.FieldsValidator;
86 import org.onap.portalapp.portal.transport.FunctionalMenuItem;
87 import org.onap.portalapp.portal.transport.LocalRole;
88 import org.onap.portalapp.portal.transport.OnboardingApp;
89 import org.onap.portalapp.portal.utils.EPCommonSystemProperties;
90 import org.onap.portalapp.portal.utils.EcompPortalUtils;
91 import org.onap.portalapp.portal.utils.PortalConstants;
92 import org.onap.portalsdk.core.onboarding.util.PortalApiConstants;
93 import org.onap.portalsdk.core.onboarding.util.PortalApiProperties;
94 import org.onap.portalsdk.core.service.DataAccessService;
95 import org.onap.portalsdk.core.service.DataAccessServiceImpl;
96 import org.onap.portalsdk.core.util.SystemProperties;
97 import org.powermock.api.mockito.PowerMockito;
98 import org.powermock.core.classloader.annotations.PowerMockIgnore;
99 import org.powermock.core.classloader.annotations.PrepareForTest;
100 import org.powermock.modules.junit4.PowerMockRunner;
101 import org.springframework.http.HttpEntity;
102 import org.springframework.http.HttpMethod;
103 import org.springframework.http.HttpStatus;
104 import org.springframework.http.ResponseEntity;
105 import org.springframework.web.client.RestTemplate;
107 import com.att.nsa.apiClient.credentials.ApiCredential;
108 import com.att.nsa.cambria.client.CambriaClientBuilders;
109 import com.att.nsa.cambria.client.CambriaIdentityManager;
111 @RunWith(PowerMockRunner.class)
112 @PowerMockIgnore({ "org.apache.http.conn.ssl.*", "javax.net.ssl.*", "javax.crypto.*" })
113 @PrepareForTest({ EcompPortalUtils.class, PortalApiProperties.class, PortalApiConstants.class, SystemProperties.class,
114 PortalConstants.class, EPCommonSystemProperties.class })
115 public class EPAppCommonServiceImplTest {
118 DataAccessService dataAccessService = new DataAccessServiceImpl();
121 AdminRolesServiceImpl adminRolesServiceImpl = new AdminRolesServiceImpl();
124 EPAppServiceImpl epAppServiceImpl = new EPAppServiceImpl();*/
127 SessionFactory sessionFactory;
133 Transaction transaction;
135 NullPointerException nullPointerException = new NullPointerException();
138 RestTemplate template = new RestTemplate();
141 public void setup() {
142 MockitoAnnotations.initMocks(this);
143 Mockito.when(sessionFactory.openSession()).thenReturn(session);
144 Mockito.when(session.beginTransaction()).thenReturn(transaction);
147 MockEPUser mockUser = new MockEPUser();
149 String ECOMP_APP_ID = "1";
150 String SUPER_ADMIN_ROLE_ID = "1";
151 String ACCOUNT_ADMIN_ROLE_ID = "999";
152 String RESTRICTED_APP_ROLE_ID = "900";
155 EPAppCommonServiceImpl epAppCommonServiceImpl = new EPAppCommonServiceImpl();
157 public EPApp mockApp() {
158 EPApp app = new EPApp();
160 app.setImageUrl("test");
161 app.setAppDescription("test");
162 app.setAppNotes("test");
163 app.setLandingPage("test");
165 app.setAppRestEndpoint("test");
166 app.setAlternateLandingPage("test");
168 app.setMlAppName("test");
169 app.setMlAppAdminId("test");
170 app.setAppBasicAuthUsername("test");
171 app.setAppBasicAuthPassword("test");
173 app.setEnabled(false);
174 app.setRolesInAAF(true);
175 app.setUebKey("test");
176 app.setUebSecret("test");
177 app.setUebTopicName("test");
178 app.setAppType(EpAppType.GUI);
183 public void getUserAsAdminAppsTest() {
184 EPApp mockApp = mockApp();
185 EPApp mockApp2 = mockApp();
187 EPUser user = mockUser.mockEPUser();
188 List<EPApp> expected = new ArrayList<>();
189 expected.add(mockApp);
190 expected.add(mockApp2);
191 String sql = "SELECT * FROM FN_APP join FN_USER_ROLE ON FN_USER_ROLE.APP_ID=FN_APP.APP_ID where "
192 + "FN_USER_ROLE.USER_ID=" + user.getId() + " AND FN_USER_ROLE.ROLE_ID=" + ACCOUNT_ADMIN_ROLE_ID
193 + " AND FN_APP.ENABLED = 'Y'";
194 Mockito.when(dataAccessService.executeSQLQuery(sql, EPApp.class, null)).thenReturn(expected);
195 Mockito.when(adminRolesServiceImpl.isAccountAdmin(user)).thenReturn(true);
196 List<EPApp> actual = epAppCommonServiceImpl.getUserAsAdminApps(user);
197 assertEquals(expected, actual);
201 public void getUserAsAdminAppsTestException() {
202 List<EPApp> expected = new ArrayList<>();
203 EPUser user = mockUser.mockEPUser();
204 String sql = "SELECT * FROM FN_APP join FN_USER_ROLE ON FN_USER_ROLE.APP_ID=FN_APP.APP_ID where "
205 + "FN_USER_ROLE.USER_ID=" + user.getId() + " AND FN_USER_ROLE.ROLE_ID=" + ACCOUNT_ADMIN_ROLE_ID
206 + " AND FN_APP.ENABLED = 'Y'";
207 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeSQLQuery(sql, EPApp.class, null);
208 Mockito.when(adminRolesServiceImpl.isAccountAdmin(user)).thenReturn(false);
209 List<EPApp> actual = epAppCommonServiceImpl.getUserAsAdminApps(user);
210 assertEquals(expected, actual);
214 public void getUserByOrgUserIdAsAdminAppsTest() {
215 EPApp mockApp = mockApp();
216 EPApp mockApp2 = mockApp();
218 EPUser user = mockUser.mockEPUser();
219 List<EPApp> expected = new ArrayList<>();
220 expected.add(mockApp);
221 expected.add(mockApp2);
222 String format = "SELECT * FROM FN_APP app INNER JOIN FN_USER_ROLE userrole ON userrole.APP_ID=app.APP_ID "
223 + "INNER JOIN FN_USER user on user.USER_ID = userrole.USER_ID "
224 + "WHERE user.org_user_id = '%s' AND userrole.ROLE_ID=" + ACCOUNT_ADMIN_ROLE_ID
225 + " AND FN_APP.ENABLED = 'Y'";
226 String sql = String.format(format, user.getOrgUserId());
227 Mockito.when(dataAccessService.executeSQLQuery(sql, EPApp.class, null)).thenReturn(expected);
228 List<EPApp> actual = epAppCommonServiceImpl.getUserByOrgUserIdAsAdminApps(user.getOrgUserId());
229 assertEquals(expected, actual);
233 public void getUserByOrgUserIdAsAdminAppsTest1() {
234 EPApp mockApp = mockApp();
235 EPApp mockApp2 = mockApp();
237 EPUser user = mockUser.mockEPUser();
238 List<EPApp> expected = new ArrayList<>();
239 expected.add(mockApp);
240 expected.add(mockApp2);
241 String format = "SELECT * FROM FN_APP app INNER JOIN FN_USER_ROLE userrole ON userrole.APP_ID=app.APP_ID "
242 + "INNER JOIN FN_USER user on user.USER_ID = userrole.USER_ID "
243 + "WHERE user.org_user_id = '%s' AND userrole.ROLE_ID=" + ACCOUNT_ADMIN_ROLE_ID
244 + " AND FN_APP.ENABLED = 'Y'";
245 String sql = String.format(format, user.getOrgUserId());
246 Mockito.when(dataAccessService.executeSQLQuery(sql, EPApp.class, null)).thenReturn(expected);
247 List<EPApp> actual = epAppCommonServiceImpl.getUserByOrgUserIdAsAdminApps(user.getOrgUserId());
248 assertEquals(expected, actual);
252 public void getUserByOrgUserIdAsAdminAppsTestException() {
253 EPUser user = mockUser.mockEPUser();
254 String format = "SELECT * FROM FN_APP app INNER JOIN FN_USER_ROLE userrole ON userrole.APP_ID=app.APP_ID "
255 + "INNER JOIN FN_USER user on user.USER_ID = userrole.USER_ID "
256 + "WHERE user.org_user_id = '%s' AND userrole.ROLE_ID=" + ACCOUNT_ADMIN_ROLE_ID
257 + " AND FN_APP.ENABLED = 'Y'";
258 String sql = String.format(format, user.getOrgUserId());
259 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeSQLQuery(sql, EPApp.class, null);
260 List<EPApp> actual = epAppCommonServiceImpl.getUserByOrgUserIdAsAdminApps(user.getOrgUserId());
264 @SuppressWarnings("deprecation")
266 public void getAppsFullListTest() {
267 EPApp mockApp = mockApp();
268 EPApp mockApp2 = mockApp();
270 List<EPApp> expected = new ArrayList<>();
271 expected.add(mockApp);
272 expected.add(mockApp2);
273 Mockito.when(dataAccessService.getList(EPApp.class, null)).thenReturn(expected);
274 List<EPApp> actual = epAppCommonServiceImpl.getAppsFullList();
275 assertEquals(expected, actual);
280 public void getEcompAppAppsFullListTest() {
281 List<EcompApp> expected = new ArrayList<>();
282 List<EcompApp> actual = epAppCommonServiceImpl.getEcompAppAppsFullList();
283 assertEquals(expected, actual);
287 public void transformAppsToEcompAppsTest() {
288 EPApp mockApp = mockApp();
289 EPApp mockApp2 = mockApp();
291 List<EPApp> epAppsList = new ArrayList<>();
292 epAppsList.add(mockApp);
293 epAppsList.add(mockApp2);
294 List<EcompApp> expected = new ArrayList<>();
295 EcompApp ecompApp = new EcompApp();
296 ecompApp.setName("test1");
297 EcompApp ecompApp2 = new EcompApp();
298 ecompApp2.setName("test2");
299 expected.add(ecompApp);
300 expected.add(ecompApp2);
301 List<EcompApp> actual = epAppCommonServiceImpl.transformAppsToEcompApps(epAppsList);
302 assertEquals(expected.size(), actual.size());
305 @SuppressWarnings({ "unchecked", "deprecation" })
307 public void getAllAppsForAllTest() {
308 EPApp mockApp = mockApp();
309 EPApp mockApp2 = mockApp();
311 List<EPApp> appsList = new ArrayList<>();
312 appsList.add(mockApp);
313 appsList.add(mockApp2);
314 List<AppsResponse> expected = new ArrayList<>();
315 AppsResponse appResponse1 = new AppsResponse(mockApp.getId(), mockApp.getName(), mockApp.isRestrictedApp(),
316 mockApp.getEnabled());
317 AppsResponse appResponse2 = new AppsResponse(mockApp2.getId(), mockApp2.getName(), mockApp2.isRestrictedApp(),
318 mockApp2.getEnabled());
319 expected.add(appResponse1);
320 expected.add(appResponse2);
321 Mockito.when((List<EPApp>) dataAccessService.getList(EPApp.class, " where id != " + ECOMP_APP_ID, "name", null))
322 .thenReturn(appsList);
323 List<AppsResponse> actual = epAppCommonServiceImpl.getAllApps(true);
324 assertEquals(expected.size(), actual.size());
327 @SuppressWarnings({ "unchecked", "deprecation" })
329 public void getAllAppsIsNotAllTest() {
330 EPApp mockApp = mockApp();
331 EPApp mockApp2 = mockApp();
333 List<EPApp> appsList = new ArrayList<>();
334 appsList.add(mockApp);
335 appsList.add(mockApp2);
336 Mockito.when((List<EPApp>) dataAccessService.getList(EPApp.class,
337 " where ( enabled = 'Y' or id = " + ECOMP_APP_ID + ")", "name", null)).thenReturn(appsList);
338 List<AppsResponse> actual = epAppCommonServiceImpl.getAllApps(false);
342 public void getAppTest() {
343 EPApp expected = mockApp();
344 Mockito.when((EPApp) dataAccessService.getDomainObject(EPApp.class, expected.getId(), null))
345 .thenReturn(expected);
346 EPApp actual = epAppCommonServiceImpl.getApp(expected.getId());
347 assertEquals(expected, actual);
351 public void getAppExceptionTest() {
352 EPApp expected = mockApp();
353 Mockito.doThrow(new NullPointerException()).when(dataAccessService).getDomainObject(EPApp.class,
354 expected.getId(), null);
355 EPApp actual = epAppCommonServiceImpl.getApp(expected.getId());
359 @SuppressWarnings("unchecked")
361 public void getAppDetailTest() {
362 EPApp expected = mockApp();
363 List<EPApp> appList = new ArrayList<>();
364 appList.add(expected);
365 final Map<String, String> params = new HashMap<String, String>();
366 params.put("appName", expected.getName());
367 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getMyloginAppDetails", params, null))
368 .thenReturn(appList);
369 EPApp actual = epAppCommonServiceImpl.getAppDetail(expected.getName());
370 assertEquals(expected, actual);
374 public void getAppDetailExceptionTest() {
375 EPApp expected = mockApp();
376 List<EPApp> appList = new ArrayList<>();
377 appList.add(expected);
378 final Map<String, String> params = new HashMap<String, String>();
379 params.put("appName", expected.getName());
380 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery("getMyloginAppDetails",
382 EPApp actual = epAppCommonServiceImpl.getAppDetail(expected.getName());
387 public void getUserProfile() {
388 EPUser user = mockUser.mockEPUser();
389 final Map<String, String> params = new HashMap<>();
390 params.put("org_user_id", user.getOrgUserId());
391 List<UserRole> userRoleList = new ArrayList<>();
392 UserRole userRole = new UserRole();
393 userRole.setFirstName("GuestT");
394 userRole.setLastName("GuestT");
395 userRole.setOrgUserId("guestT");
396 userRole.setRoleId(1l);
397 userRole.setRoleName("Test");
398 userRole.setUser_Id(-1l);
399 userRoleList.add(userRole);
400 UserRoles expected = new UserRoles(userRole);
401 Mockito.when(dataAccessService.executeNamedQuery("getUserRoles", params, null)).thenReturn(userRoleList);
402 UserRoles actual = epAppCommonServiceImpl.getUserProfile(user.getOrgUserId());
403 assertEquals(expected.getOrgUserId(), actual.getOrgUserId());
407 public void getUserProfileNullTest() {
408 EPUser user = mockUser.mockEPUser();
409 final Map<String, String> params = new HashMap<>();
410 params.put("org_user_id", user.getOrgUserId());
411 List<UserRole> userRoleList = new ArrayList<>();
412 Mockito.when(dataAccessService.executeNamedQuery("getUserRoles", params, null)).thenReturn(userRoleList);
413 UserRoles actual = epAppCommonServiceImpl.getUserProfile(user.getOrgUserId());
418 public void getUserProfileNormalizedTest() {
419 EPUser user = mockUser.mockEPUser();
421 user.setLoginId("guestT");
422 final Map<String, String> params = new HashMap<>();
423 params.put("org_user_id", user.getOrgUserId());
424 List<UserRole> userRoleList = new ArrayList<>();
425 UserRole userRole = new UserRole();
426 userRole.setFirstName("GuestT");
427 userRole.setLastName("GuestT");
428 userRole.setOrgUserId("guestT");
429 userRole.setRoleId(1l);
430 userRole.setRoleName("Test");
431 userRole.setUser_Id(-1l);
432 userRoleList.add(userRole);
433 UserRoles expected = new UserRoles(userRole);
434 Mockito.when(dataAccessService.executeNamedQuery("getUserRoles", params, null)).thenReturn(userRoleList);
435 UserRoles actual = epAppCommonServiceImpl.getUserProfileNormalized(user);
436 assertEquals(expected.getOrgUserId(), actual.getOrgUserId());
440 public void getRestrictedAppRolesTest() {
441 EPUser user = mockUser.mockEPUser();
442 EPApp mockApp = mockApp();
443 mockApp.setAppType(EpAppType.HYPERLINK);
444 user.setLoginId("guestT");
445 List<LocalRole> expected = new ArrayList<>();
446 LocalRole localRole = new LocalRole();
447 localRole.setRoleId(1);
448 localRole.setRolename("test1");
449 expected.add(localRole);
450 String sql = "SELECT ROLE_ID, ROLE_NAME from FN_ROLE where UPPER(ACTIVE_YN) = 'Y' AND ROLE_ID = '"
451 + RESTRICTED_APP_ROLE_ID + "'";
452 Mockito.when(dataAccessService.executeSQLQuery(sql, LocalRole.class, null)).thenReturn(expected);
453 Mockito.when((EPApp) dataAccessService.getDomainObject(EPApp.class, mockApp.getId(), null)).thenReturn(mockApp);
454 List<LocalRole> actual = epAppCommonServiceImpl.getAppRoles(mockApp.getId());
455 assertEquals(expected, actual);
459 public void getPoralAppRolesTest() {
460 EPUser user = mockUser.mockEPUser();
461 EPApp mockApp = mockApp();
462 mockApp.setAppType(EpAppType.GUI);
464 user.setLoginId("guestT");
465 List<LocalRole> expected = new ArrayList<>();
466 LocalRole localRole = new LocalRole();
467 localRole.setRoleId(1);
468 localRole.setRolename("test1");
469 expected.add(localRole);
470 String sql = "SELECT ROLE_ID, ROLE_NAME from FN_ROLE where UPPER(ACTIVE_YN) = 'Y' AND APP_ID IS NULL";
471 Mockito.when(dataAccessService.executeSQLQuery(sql, LocalRole.class, null)).thenReturn(expected);
472 Mockito.when((EPApp) dataAccessService.getDomainObject(EPApp.class, mockApp.getId(), null)).thenReturn(mockApp);
473 List<LocalRole> actual = epAppCommonServiceImpl.getAppRoles(mockApp.getId());
474 assertEquals(expected, actual);
478 public void getNonPortalAndNonRestrictedAppRolesTest() {
479 EPUser user = mockUser.mockEPUser();
480 EPApp mockApp = mockApp();
481 mockApp.setAppType(EpAppType.GUI);
483 user.setLoginId("guestT");
484 List<LocalRole> expected = new ArrayList<>();
485 LocalRole localRole = new LocalRole();
486 localRole.setRoleId(1);
487 localRole.setRolename("test1");
488 expected.add(localRole);
489 String sql = "SELECT ROLE_ID, ROLE_NAME from FN_ROLE where UPPER(ACTIVE_YN) = 'Y' AND APP_ID = '"
490 + mockApp.getId() + "'";
491 Mockito.when(dataAccessService.executeSQLQuery(sql, LocalRole.class, null)).thenReturn(expected);
492 Mockito.when((EPApp) dataAccessService.getDomainObject(EPApp.class, mockApp.getId(), null)).thenReturn(mockApp);
493 List<LocalRole> actual = epAppCommonServiceImpl.getAppRoles(mockApp.getId());
494 assertEquals(expected, actual);
498 public void getAdminAppsTest() {
499 EPUser user = mockUser.mockEPUser();
501 List<AppIdAndNameTransportModel> expected = new ArrayList<>();
502 AppIdAndNameTransportModel appIdAndNameTransportModel = new AppIdAndNameTransportModel();
503 appIdAndNameTransportModel.setId(1l);
504 appIdAndNameTransportModel.setName("test1");
505 expected.add(appIdAndNameTransportModel);
506 Mockito.when(adminRolesServiceImpl.isAccountAdmin(user)).thenReturn(true);
507 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 "
508 + "where userrole.USER_ID = %d AND userrole.ROLE_ID=" + ACCOUNT_ADMIN_ROLE_ID
509 + " AND (app.ENABLED = 'Y' OR app.APP_ID=1)";
510 String sql = String.format(format, user.getId());
511 Mockito.when(dataAccessService.executeSQLQuery(sql, AppIdAndNameTransportModel.class, null))
512 .thenReturn(expected);
513 List<AppIdAndNameTransportModel> actual = epAppCommonServiceImpl.getAdminApps(user);
514 assertEquals(expected, actual);
518 public void getAdminAppsExceptionTest() {
519 EPUser user = mockUser.mockEPUser();
521 List<AppIdAndNameTransportModel> expected = new ArrayList<>();
522 Mockito.when(adminRolesServiceImpl.isAccountAdmin(user)).thenReturn(true);
523 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 "
524 + "where userrole.USER_ID = %d AND userrole.ROLE_ID=" + ACCOUNT_ADMIN_ROLE_ID
525 + " AND (app.ENABLED = 'Y' OR app.APP_ID=1)";
526 String sql = String.format(format, user.getId());
527 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeSQLQuery(sql,
528 AppIdAndNameTransportModel.class, null);
529 List<AppIdAndNameTransportModel> actual = epAppCommonServiceImpl.getAdminApps(user);
530 assertEquals(expected, actual);
534 @SuppressWarnings("unchecked")
536 public void addOnboardingAppUnKnownHostExceptionTest() throws Exception {
537 PowerMockito.mockStatic(PortalApiConstants.class);
538 PowerMockito.mockStatic(PortalApiProperties.class);
539 EPUser user = mockUser.mockEPUser();
540 List<EPApp> mockAppList = new ArrayList<>();
541 OnboardingApp onboardApp = new OnboardingApp();
542 onboardApp.setRestrictedApp(false);
543 onboardApp.setAppName("test1");
544 onboardApp.setLandingPage("http://test.com");
545 onboardApp.setIsOpen(false);
546 onboardApp.setIsEnabled(true);
547 onboardApp.setAppBasicAuthUsername("test123");
548 onboardApp.setAppBasicAuthPassword("test123");
549 List<Criterion> restrictionsList = new ArrayList<Criterion>();
550 Criterion urlCrit = Restrictions.eq("url", onboardApp.getLandingPage());
551 Criterion nameCrit = Restrictions.eq("name", onboardApp.getAppName());
552 Criterion orCrit = Restrictions.or(urlCrit, nameCrit);
553 restrictionsList.add(orCrit);
554 List<String> uebList = new ArrayList<>();
555 uebList.add("localhost");
556 com.att.nsa.apiClient.credentials.ApiCredential apiCredential = new ApiCredential(user.getEmail(),
557 "ECOMP Portal Owner");
558 CambriaIdentityManager mockIm = Mockito
559 .spy(new CambriaClientBuilders.IdentityManagerBuilder().usingHosts(uebList).build());
560 Mockito.doReturn(apiCredential).when(mockIm).createApiKey(user.getEmail(), "ECOMP Portal Owner");
561 Mockito.when(PortalApiProperties.getProperty(PortalApiConstants.UEB_URL_LIST)).thenReturn("localhost");
562 Mockito.when((List<EPApp>) dataAccessService.getList(EPApp.class, null, restrictionsList, null))
563 .thenReturn(mockAppList);
564 FieldsValidator expected = new FieldsValidator();
565 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
566 FieldsValidator actual = epAppCommonServiceImpl.addOnboardingApp(onboardApp, user);
567 assertEquals(expected, actual);
570 @SuppressWarnings("unchecked")
572 public void modifyOnboardingAppTest() throws Exception {
573 EPUser user = mockUser.mockEPUser();
574 EPApp mockApp = mockApp();
575 mockApp.setName("test1");
577 mockApp.setLandingPage("http://test.com");
578 mockApp.setAppBasicAuthUsername("test123");
579 mockApp.setAppBasicAuthPassword("*******");
580 mockApp.setAppType(EpAppType.GUI);
581 mockApp.setEnabled(true);
582 mockApp.setOpen(false);
583 List<EPApp> mockAppList = new ArrayList<>();
584 mockAppList.add(mockApp);
585 OnboardingApp onboardApp = new OnboardingApp();
586 onboardApp.setRestrictedApp(false);
587 onboardApp.setAppName("test1");
588 onboardApp.setId(2l);
589 onboardApp.setLandingPage("http://test.com");
590 onboardApp.setRestUrl("http://test.com");
591 onboardApp.setIsOpen(false);
592 onboardApp.setIsEnabled (true);
593 onboardApp.setThumbnail("test123imgthumbnail");
594 onboardApp.setAppBasicAuthUsername("test123");
595 onboardApp.setAppBasicAuthPassword("*******");
596 onboardApp.setRolesInAAF(true);
597 onboardApp.setMyLoginsAppName("test123");
598 onboardApp.setMyLoginsAppOwner("test123");
599 onboardApp.setNameSpace("com.test");
600 onboardApp.setModeOfIntegration("sdk");
601 onboardApp.setAppAck(true);
602 onboardApp.setUsesCadi(false);
603 onboardApp.setApplicationType("1");
605 List<Criterion> restrictionsList1 = new ArrayList<Criterion>();
606 Criterion idCrit = Restrictions.eq("id", onboardApp.getId());
607 Criterion urlCrit = Restrictions.eq("url", onboardApp.getLandingPage());
608 Criterion nameCrit = Restrictions.eq("name", onboardApp.getAppName());
609 Criterion orCrit = Restrictions.or(idCrit, urlCrit, nameCrit);
610 restrictionsList1.add(orCrit);
611 Mockito.when((List<EPApp>) dataAccessService.getList(EPApp.class, null, restrictionsList1, null))
612 .thenReturn(mockAppList);
613 Mockito.when((EPApp) session.get(EPApp.class, onboardApp.getId())).thenReturn(mockApp);
614 String sql = "SELECT m.menu_id, m.column_num, m.text, m.parent_menu_id, m.url, m.active_yn "
615 + "FROM fn_menu_functional m, fn_menu_functional_roles r " + "WHERE m.menu_id = r.menu_id "
616 + " AND r.app_id = '" + onboardApp.getId() + "' ";
617 List<Integer> roles = new ArrayList<>();
620 List<FunctionalMenuItem> menuItems = new ArrayList<>();
621 FunctionalMenuItem functionalMenuItem = new FunctionalMenuItem();
622 functionalMenuItem.setRestrictedApp(false);
623 functionalMenuItem.setUrl("http://test1.com");
624 functionalMenuItem.setRoles(roles);
625 menuItems.add(functionalMenuItem);
626 Mockito.when(dataAccessService.executeSQLQuery(sql, FunctionalMenuItem.class, null)).thenReturn(menuItems);
627 Mockito.when((FunctionalMenuItem) session.get(FunctionalMenuItem.class, functionalMenuItem.menuId))
628 .thenReturn(functionalMenuItem);
629 FieldsValidator expected = new FieldsValidator();
630 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
631 FieldsValidator actual = epAppCommonServiceImpl.modifyOnboardingApp(onboardApp, user);
632 assertEquals(expected, actual);
636 public void saveWidgetsSortManualTest() {
637 EPUser user = mockUser.mockEPUser();
638 List<EPWidgetsManualSortPreference> mockEPManualWidgets = new ArrayList<>();
639 EPWidgetsManualSortPreference epWidgetsManualSortPreference = new EPWidgetsManualSortPreference();
640 epWidgetsManualSortPreference.setUserId(user.getId());
641 epWidgetsManualSortPreference.setWidgetCol(1);
642 epWidgetsManualSortPreference.setWidgetHeight(1);
643 epWidgetsManualSortPreference.setWidgetId(1l);
644 epWidgetsManualSortPreference.setWidgetRow(1);
645 epWidgetsManualSortPreference.setWidgetWidth(1);
646 mockEPManualWidgets.add(epWidgetsManualSortPreference);
647 final Map<String, Long> params = new HashMap<>();
648 params.put("userId", user.getId());
649 Mockito.when(dataAccessService.executeNamedQuery("userWidgetManualSortPrfQuery", params, null))
650 .thenReturn(mockEPManualWidgets);
651 FieldsValidator expected = new FieldsValidator();
652 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
653 List<EPWidgetsSortPreference> epWidgetsSortPreferenceList = new ArrayList<>();
654 EPWidgetsSortPreference mockEPWidgetsSortPreference = new EPWidgetsSortPreference();
655 mockEPWidgetsSortPreference.setRow(2);
656 mockEPWidgetsSortPreference.setHeaderText("test");
657 mockEPWidgetsSortPreference.setSizeX(2);
658 mockEPWidgetsSortPreference.setSizeY(2);
659 mockEPWidgetsSortPreference.setWidgetid(2l);
660 mockEPWidgetsSortPreference.setWidgetIdentifier("test");
661 mockEPWidgetsSortPreference.setCol(2);
662 epWidgetsSortPreferenceList.add(mockEPWidgetsSortPreference);
663 FieldsValidator actual = epAppCommonServiceImpl.saveWidgetsSortManual(epWidgetsSortPreferenceList, user);
664 assertEquals(expected, actual);
668 public void saveWidgetsSortManualExistingRecordTest() {
669 EPUser user = mockUser.mockEPUser();
670 List<EPWidgetsManualSortPreference> mockEPManualWidgets = new ArrayList<>();
671 EPWidgetsManualSortPreference epWidgetsManualSortPreference = new EPWidgetsManualSortPreference();
672 epWidgetsManualSortPreference.setUserId(user.getId());
673 epWidgetsManualSortPreference.setWidgetCol(1);
674 epWidgetsManualSortPreference.setWidgetHeight(1);
675 epWidgetsManualSortPreference.setWidgetId(2l);
676 epWidgetsManualSortPreference.setWidgetRow(1);
677 epWidgetsManualSortPreference.setWidgetWidth(1);
678 mockEPManualWidgets.add(epWidgetsManualSortPreference);
679 final Map<String, Long> params = new HashMap<>();
680 params.put("userId", user.getId());
681 Mockito.when(dataAccessService.executeNamedQuery("userWidgetManualSortPrfQuery", params, null))
682 .thenReturn(mockEPManualWidgets);
683 FieldsValidator expected = new FieldsValidator();
684 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
685 List<EPWidgetsSortPreference> epWidgetsSortPreferenceList = new ArrayList<>();
686 EPWidgetsSortPreference mockEPWidgetsSortPreference = new EPWidgetsSortPreference();
687 mockEPWidgetsSortPreference.setRow(2);
688 mockEPWidgetsSortPreference.setHeaderText("test");
689 mockEPWidgetsSortPreference.setSizeX(2);
690 mockEPWidgetsSortPreference.setSizeY(2);
691 mockEPWidgetsSortPreference.setWidgetid(2l);
692 mockEPWidgetsSortPreference.setWidgetIdentifier("test");
693 mockEPWidgetsSortPreference.setCol(2);
694 epWidgetsSortPreferenceList.add(mockEPWidgetsSortPreference);
695 FieldsValidator actual = epAppCommonServiceImpl.saveWidgetsSortManual(epWidgetsSortPreferenceList, user);
696 assertEquals(expected, actual);
700 public void deleteUserWidgetSortPrefTest() {
701 EPUser user = mockUser.mockEPUser();
702 List<EPWidgetsManualSortPreference> mockEPManualWidgets = new ArrayList<>();
703 EPWidgetsManualSortPreference epWidgetsManualSortPreference = new EPWidgetsManualSortPreference();
704 epWidgetsManualSortPreference.setUserId(user.getId());
705 epWidgetsManualSortPreference.setWidgetCol(1);
706 epWidgetsManualSortPreference.setWidgetHeight(1);
707 epWidgetsManualSortPreference.setWidgetId(2l);
708 epWidgetsManualSortPreference.setWidgetRow(1);
709 epWidgetsManualSortPreference.setWidgetWidth(1);
710 mockEPManualWidgets.add(epWidgetsManualSortPreference);
711 final Map<String, Long> params = new HashMap<>();
712 params.put("userId", user.getId());
713 Mockito.when(dataAccessService.executeNamedQuery("userWidgetManualSortPrfQuery", params, null))
714 .thenReturn(mockEPManualWidgets);
715 FieldsValidator expected = new FieldsValidator();
716 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
717 List<EPWidgetsSortPreference> epWidgetsSortPreferenceList = new ArrayList<>();
718 EPWidgetsSortPreference mockEPWidgetsSortPreference = new EPWidgetsSortPreference();
719 mockEPWidgetsSortPreference.setRow(2);
720 mockEPWidgetsSortPreference.setHeaderText("test");
721 mockEPWidgetsSortPreference.setSizeX(2);
722 mockEPWidgetsSortPreference.setSizeY(2);
723 mockEPWidgetsSortPreference.setWidgetid(2l);
724 mockEPWidgetsSortPreference.setWidgetIdentifier("test");
725 mockEPWidgetsSortPreference.setCol(2);
726 epWidgetsSortPreferenceList.add(mockEPWidgetsSortPreference);
727 FieldsValidator actual = epAppCommonServiceImpl.deleteUserWidgetSortPref(epWidgetsSortPreferenceList, user);
728 assertEquals(expected, actual);
732 public void saveAppsSortPreferenceForNewUserTest() {
733 EPUser user = mockUser.mockEPUser();
734 List<EPUserAppsSortPreference> mockEPAppSortPrefList = new ArrayList<>();
735 final Map<String, Long> params = new HashMap<>();
736 params.put("userId", user.getId());
737 Mockito.when(dataAccessService.executeNamedQuery("userAppsSortPreferenceQuery", params, null))
738 .thenReturn(mockEPAppSortPrefList);
739 FieldsValidator expected = new FieldsValidator();
740 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
741 EPAppsSortPreference mockEPAppsSortPreference = new EPAppsSortPreference();
742 mockEPAppsSortPreference.setIndex(1);
743 mockEPAppsSortPreference.setTitle("Last Used");
744 mockEPAppsSortPreference.setValue("L");
745 FieldsValidator actual = epAppCommonServiceImpl.saveAppsSortPreference(mockEPAppsSortPreference, user);
746 assertEquals(expected, actual);
750 public void saveAppsSortPreferenceUpdateTest() {
751 EPUser user = mockUser.mockEPUser();
752 List<EPUserAppsSortPreference> mockEPAppSortPrefList = new ArrayList<>();
753 EPUserAppsSortPreference mockEPAppSortPref = new EPUserAppsSortPreference();
754 mockEPAppSortPref.setSortPref("L");
755 mockEPAppSortPref.setId(2l);
756 mockEPAppSortPref.setUserId((int) (long) user.getId());
757 mockEPAppSortPrefList.add(mockEPAppSortPref);
758 final Map<String, Long> params = new HashMap<>();
759 params.put("userId", user.getId());
760 Mockito.when(dataAccessService.executeNamedQuery("userAppsSortPreferenceQuery", params, null))
761 .thenReturn(mockEPAppSortPrefList);
762 FieldsValidator expected = new FieldsValidator();
763 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
764 EPAppsSortPreference mockEPAppsSortPreference = new EPAppsSortPreference();
765 mockEPAppsSortPreference.setIndex(1);
766 mockEPAppsSortPreference.setTitle("Last Used");
767 mockEPAppsSortPreference.setValue("L");
768 FieldsValidator actual = epAppCommonServiceImpl.saveAppsSortPreference(mockEPAppsSortPreference, user);
769 assertEquals(expected, actual);
773 public void saveAppsSortPreferenceExceptionTest() {
774 EPUser user = mockUser.mockEPUser();
775 final Map<String, Long> params = new HashMap<>();
776 params.put("userId", user.getId());
777 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
778 FieldsValidator expected = new FieldsValidator();
779 expected.setHttpStatusCode(500l);
780 //expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
781 EPAppsSortPreference mockEPAppsSortPreference = new EPAppsSortPreference();
782 mockEPAppsSortPreference.setIndex(1);
783 mockEPAppsSortPreference.setTitle("Last Used");
784 mockEPAppsSortPreference.setValue("L");
785 FieldsValidator actual = epAppCommonServiceImpl.saveAppsSortPreference(mockEPAppsSortPreference, user);
786 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
790 public void getUserAppsSortTypePreferenceTest() {
791 EPUser user = mockUser.mockEPUser();
792 final Map<String, Long> params = new HashMap<>();
793 List<EPUserAppsSortPreference> mockEPAppSortPrefList = new ArrayList<>();
794 EPUserAppsSortPreference mockEPAppSortPref = new EPUserAppsSortPreference();
795 mockEPAppSortPref.setSortPref("L");
796 mockEPAppSortPref.setId(2l);
797 mockEPAppSortPref.setUserId((int) (long) user.getId());
798 mockEPAppSortPrefList.add(mockEPAppSortPref);
799 params.put("userId", user.getId());
800 Mockito.when(dataAccessService.executeNamedQuery("userAppsSortPreferenceQuery", params, null))
801 .thenReturn(mockEPAppSortPrefList);
802 String actual = epAppCommonServiceImpl.getUserAppsSortTypePreference(user);
803 assertEquals(mockEPAppSortPref.getSortPref(), actual);
807 public void getUserAppsSortTypePreferenceExceptionTest() {
808 EPUser user = mockUser.mockEPUser();
809 final Map<String, Long> params = new HashMap<>();
810 List<EPUserAppsSortPreference> mockEPAppSortPrefList = new ArrayList<>();
811 EPUserAppsSortPreference mockEPAppSortPref = new EPUserAppsSortPreference();
812 mockEPAppSortPref.setSortPref("L");
813 mockEPAppSortPref.setId(2l);
814 mockEPAppSortPref.setUserId((int) (long) user.getId());
815 mockEPAppSortPrefList.add(mockEPAppSortPref);
816 params.put("userId", user.getId());
817 Mockito.doThrow(new NullPointerException()).when(dataAccessService)
818 .executeNamedQuery("userAppsSortPreferenceQuery", params, null);
819 String actual = epAppCommonServiceImpl.getUserAppsSortTypePreference(user);
824 public void deleteUserAppSortManualTest() {
825 EPUser user = mockUser.mockEPUser();
826 EPApp mockApp = mockApp();
828 final Map<String, Long> params = new HashMap<>();
829 List<EPUserAppsManualSortPreference> epManualApps = new ArrayList<EPUserAppsManualSortPreference>();
830 EPUserAppsManualSortPreference epManualApp = new EPUserAppsManualSortPreference();
831 epManualApp.setAppId(mockApp.getId());
832 epManualApp.setAppManualSortOrder(1);
833 epManualApp.setId(1l);
834 epManualApp.setUserId(user.getId());
835 epManualApps.add(epManualApp);
836 params.put("userId", user.getId());
837 Mockito.when(dataAccessService.executeNamedQuery("userAppsManualSortPrfQuery", params, null)).thenReturn(epManualApps);
838 EPDeleteAppsManualSortPref delAppSortManual = new EPDeleteAppsManualSortPref();
839 delAppSortManual.setAppId(mockApp.getId());
840 delAppSortManual.setPending(false);
841 delAppSortManual.setSelect(false);
842 FieldsValidator actual = epAppCommonServiceImpl.deleteUserAppSortManual(delAppSortManual, user);
843 FieldsValidator expected = new FieldsValidator();
844 expected.setHttpStatusCode(200l);
845 assertEquals(expected, actual);
849 public void deleteUserAppSortManualExceptionTest() {
850 EPUser user = mockUser.mockEPUser();
851 EPApp mockApp = mockApp();
853 final Map<String, Long> params = new HashMap<>();
854 List<EPUserAppsManualSortPreference> epManualApps = new ArrayList<EPUserAppsManualSortPreference>();
855 EPUserAppsManualSortPreference epManualApp = new EPUserAppsManualSortPreference();
856 epManualApp.setAppId(mockApp.getId());
857 epManualApp.setAppManualSortOrder(1);
858 epManualApp.setId(1l);
859 epManualApp.setUserId(user.getId());
860 epManualApps.add(epManualApp);
861 params.put("userId", user.getId());
862 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery("userAppsManualSortPrfQuery", params, null);
863 EPDeleteAppsManualSortPref delAppSortManual = new EPDeleteAppsManualSortPref();
864 delAppSortManual.setAppId(mockApp.getId());
865 delAppSortManual.setPending(false);
866 delAppSortManual.setSelect(false);
867 FieldsValidator actual = epAppCommonServiceImpl.deleteUserAppSortManual(delAppSortManual, user);
868 FieldsValidator expected = new FieldsValidator();
869 expected.setHttpStatusCode(500l);
870 assertEquals(expected, actual);
873 @SuppressWarnings("unchecked")
875 public void getAppDetailByAppNameTest(){
876 String appName = "test";
877 EPApp expectedResult = mockApp();
878 List<EPApp> appList = new ArrayList<>();
879 appList.add(expectedResult);
880 final Map<String, String> params = new HashMap<String, String>();
881 params.put("appName", expectedResult.getName());
882 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAppDetailsByAppName", params, null))
883 .thenReturn(appList);
884 EPApp actualResult = epAppCommonServiceImpl.getAppDetailByAppName(appName);
885 assertEquals(expectedResult, actualResult);
888 @SuppressWarnings("unchecked")
890 public void getAppDetailByAppNameExceptionTest(){
891 String appName = null;
892 EPApp expectedResult = null;
893 List<EPApp> appList = new ArrayList<>();
894 appList.add(expectedResult);
895 final Map<String, String> params = new HashMap<String, String>();
896 params.put("appName", null);
897 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAppDetailsByAppName", params, null))
898 .thenReturn(appList);
899 EPApp actualResult = epAppCommonServiceImpl.getAppDetailByAppName(appName);
900 assertEquals(expectedResult, actualResult);
903 @SuppressWarnings("unchecked")
905 public void getAppsForSuperAdminAndAccountAdminTest(){
906 String sql = "SELECT app.APP_ID, app.APP_NAME, app.APP_TYPE FROM FN_APP app "
907 + "where app.ENABLED = 'Y' AND app.app_type = 1";
908 EPUser user = mockUser.mockEPUser();
909 List<AppIdAndNameTransportModel> expected = null;
910 Mockito.when(adminRolesServiceImpl.isSuperAdmin(user)).thenReturn(true);
911 Mockito.when(adminRolesServiceImpl.isAccountAdmin(user)).thenReturn(true);
912 List<AppIdAndNameTransportModel> actual = null;
913 Mockito.when((List<AppIdAndNameTransportModel>) dataAccessService.executeSQLQuery(sql, AppIdAndNameTransportModel.class, null))
915 actual = epAppCommonServiceImpl.getAppsForSuperAdminAndAccountAdmin(user);
916 assertEquals(expected, actual);
919 @SuppressWarnings("unchecked")
921 public void getAppsForSuperAdminAndNotAccountAdminTest(){
922 String sql = "SELECT app.APP_ID, app.APP_NAME, app.APP_TYPE FROM FN_APP app "
923 + "where app.ENABLED = 'Y' AND app.app_type = 1";
924 EPUser user = mockUser.mockEPUser();
925 List<AppIdAndNameTransportModel> expected = new ArrayList<AppIdAndNameTransportModel>();
926 Mockito.when(adminRolesServiceImpl.isSuperAdmin(user)).thenReturn(false);
927 Mockito.when(adminRolesServiceImpl.isAccountAdmin(user)).thenReturn(true);
928 List<AppIdAndNameTransportModel> actual = null;
929 Mockito.when((List<AppIdAndNameTransportModel>) dataAccessService.executeSQLQuery(sql, AppIdAndNameTransportModel.class, null))
931 actual = epAppCommonServiceImpl.getAppsForSuperAdminAndAccountAdmin(user);
932 assertEquals(expected, actual);
935 @SuppressWarnings("unchecked")
937 public void getAppsForAdminAndAccountAdminTest(){
938 String sql = "SELECT app.APP_ID, app.APP_NAME, app.APP_TYPE FROM FN_APP app "
939 + "where app.ENABLED = 'Y' AND app.app_type = 1";
940 EPUser user = mockUser.mockEPUser();
941 List<AppIdAndNameTransportModel> expected = null;
942 Mockito.when(adminRolesServiceImpl.isSuperAdmin(user)).thenReturn(true);
943 List<AppIdAndNameTransportModel> actual = null;
944 Mockito.when((List<AppIdAndNameTransportModel>) dataAccessService.executeSQLQuery(sql, AppIdAndNameTransportModel.class, null))
946 actual = epAppCommonServiceImpl.getAppsForSuperAdminAndAccountAdmin(user);
947 assertEquals(expected, actual);
951 public void getAppsForSuperAdminAndAccountAdminExceptionTest(){
952 String sql = "SELECT app.APP_ID, app.APP_NAME, app.APP_TYPE FROM FN_APP app "
953 + "where app.ENABLED = 'Y' AND app.app_type = 1";
954 EPUser user = mockUser.mockEPUser();
955 List<AppIdAndNameTransportModel> expected = new ArrayList<AppIdAndNameTransportModel>();
956 Mockito.when(adminRolesServiceImpl.isSuperAdmin(user)).thenReturn(true);
957 List<AppIdAndNameTransportModel> actual = null;
958 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeSQLQuery(sql, AppIdAndNameTransportModel.class, null);
959 actual = epAppCommonServiceImpl.getAppsForSuperAdminAndAccountAdmin(user);
960 assertEquals(expected, actual);
964 public void getDataAccessServiceTest(){
965 assertEquals(epAppCommonServiceImpl.getDataAccessService(), epAppCommonServiceImpl.getDataAccessService());
968 @SuppressWarnings("unchecked")
970 public void getAppsAdminsTest(){
971 List<AdminUserApplications> expected = new ArrayList<AdminUserApplications>();
972 List<AdminUserApplications> actual = null;
973 List<AdminUserApp> list = new ArrayList<AdminUserApp>();
974 Map<String, String> params = new HashMap<>();
975 params.put("accountAdminRoleId", ACCOUNT_ADMIN_ROLE_ID);
976 Mockito.when((List<AdminUserApp>) dataAccessService.executeNamedQuery("getAppsAdmins", params, null)).thenReturn(list);
977 actual = epAppCommonServiceImpl.getAppsAdmins();
978 assertEquals(expected, actual);
982 public void getAppsAdminsExceptionTest(){
983 List<AdminUserApplications> expected = null;
984 List<AdminUserApplications> actual = null;
985 Map<String, String> params = new HashMap<>();
986 params.put("accountAdminRoleId", ACCOUNT_ADMIN_ROLE_ID);
987 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery("getAppsAdmins", params, null);
988 actual = epAppCommonServiceImpl.getAppsAdmins();
989 assertEquals(expected, actual);
992 @SuppressWarnings("unchecked")
994 public void getAppsAdminsAggregateResultsTest(){
995 List<AdminUserApplications> expected = new ArrayList<AdminUserApplications>();
996 AdminUserApp adminUserApp = new AdminUserApp();
997 AdminUserApplications adminUserApplications = new AdminUserApplications(adminUserApp);
998 expected.add(adminUserApplications);
999 List<AdminUserApplications> actual = null;
1000 List<AdminUserApp> list = new ArrayList<AdminUserApp>();
1001 AdminUserApp adminUserApp1 = new AdminUserApp();
1002 list.add(adminUserApp1);
1003 Map<String, String> params = new HashMap<>();
1004 params.put("accountAdminRoleId", ACCOUNT_ADMIN_ROLE_ID);
1005 Mockito.when((List<AdminUserApp>) dataAccessService.executeNamedQuery("getAppsAdmins", params, null)).thenReturn(list);
1006 actual = epAppCommonServiceImpl.getAppsAdmins();
1007 assertEquals(expected.size(), actual.size());
1010 @SuppressWarnings("unchecked")
1012 public void getUserAppsTest(){
1014 EPApp epApp = new EPApp();
1015 epApp.setOpen(false);
1016 List<EPApp> expected = new ArrayList<EPApp>();
1017 List<EPApp> list = new ArrayList<EPApp>();
1018 EPUser epUser = new EPUser();
1020 Mockito.when((List<EPApp>) dataAccessService.executeSQLQuery(sql, EPApp.class, null)).thenReturn(list);
1021 List<EPApp> actual = epAppCommonServiceImpl.getUserApps(epUser);
1022 assertEquals(expected.size(), actual.size());
1025 @SuppressWarnings("unchecked")
1027 public void getUserAppsUserGuestTest(){
1029 List<EPApp> expected = new ArrayList<EPApp>();
1030 List<EPApp> list = new ArrayList<EPApp>();
1031 EPUser epUser = new EPUser();
1032 epUser.setGuest(true);
1033 Mockito.when((List<EPApp>) dataAccessService.executeSQLQuery(sql, EPApp.class, null)).thenReturn(list);
1034 List<EPApp> actual = epAppCommonServiceImpl.getUserApps(epUser);
1035 assertEquals(expected.size(), actual.size());
1038 @SuppressWarnings("unchecked")
1040 public void getPersAdminAppsTest(){
1041 List<EPApp> expected = new ArrayList<EPApp>();
1042 final Map<String, Long> params = new HashMap<>();
1043 params.put("userId", (long)123);
1044 EPUser epUser = new EPUser();
1045 List<EPApp> list = new ArrayList<EPApp>();
1046 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getPersAdminApps", params, null)).thenReturn(list);
1047 List<EPApp> actual = epAppCommonServiceImpl.getPersAdminApps(epUser);
1048 assertEquals(expected, actual);
1051 @SuppressWarnings("unchecked")
1053 public void getPersUserAppsTest(){
1054 List<EPApp> expected = new ArrayList<EPApp>();
1055 EPUser epUser = new EPUser();
1056 final Map<String, Long> params = new HashMap<>();
1057 params.put("userId", (long)123);
1058 List<EPApp> list = new ArrayList<EPApp>();
1059 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getPersUserApps", params, null)).thenReturn(list);
1060 List<EPApp> actual = epAppCommonServiceImpl.getPersUserApps(epUser);
1061 assertEquals(expected, actual);
1064 @SuppressWarnings("unchecked")
1066 public void getUserAppCatalogTest(){
1067 List<AppCatalogItem> expected = new ArrayList<AppCatalogItem>();
1068 EPUser epUser = new EPUser();
1069 final Map<String, Long> params = new HashMap<>();
1070 params.put("userId", (long)123);
1071 List<AppCatalogItem> list = new ArrayList<AppCatalogItem>();
1072 Mockito.when((List<AppCatalogItem>) dataAccessService.executeNamedQuery("getUserAppCatalog", params, null)).thenReturn(list);
1073 List<AppCatalogItem> actual = epAppCommonServiceImpl.getUserAppCatalog(epUser);
1074 assertEquals(expected, actual);
1077 @SuppressWarnings("unchecked")
1079 public void getAdminAppCatalogTest(){
1080 List<AppCatalogItem> expected = new ArrayList<AppCatalogItem>();
1081 EPUser epUser = new EPUser();
1082 final Map<String, Long> params = new HashMap<>();
1083 params.put("userId", (long)123);
1084 List<AppCatalogItem> list = new ArrayList<AppCatalogItem>();
1085 Mockito.when((List<AppCatalogItem>) dataAccessService.executeNamedQuery("getAdminAppCatalog", params, null)).thenReturn(list);
1086 List<AppCatalogItem> actual = epAppCommonServiceImpl.getAdminAppCatalog(epUser);
1087 assertEquals(expected, actual);
1090 @SuppressWarnings("unchecked")
1092 public void getAppsOrderByNameTest(){
1093 List<EPApp> expected = new ArrayList<EPApp>();
1094 EPUser epUser = new EPUser();
1095 List<EPApp> list = new ArrayList<EPApp>();
1096 final Map<String, Long> params = new HashMap<>();
1097 params.put("userId", (long)123);
1098 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1099 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getPersAdminAppsOrderByName", params, null)).thenReturn(list);
1100 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByName(epUser);
1101 assertEquals(expected, actual);
1104 @SuppressWarnings("unchecked")
1106 public void getAppsOrderByNameNotSuperAdminTest(){
1107 List<EPApp> expected = new ArrayList<EPApp>();
1108 EPUser epUser = new EPUser();
1109 List<EPApp> list = new ArrayList<EPApp>();
1110 final Map<String, Long> params = new HashMap<>();
1111 params.put("userId", (long)123);
1112 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(false);
1113 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getPersAdminAppsOrderByName", params, null)).thenReturn(list);
1114 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByName(epUser);
1115 assertEquals(expected, actual);
1119 public void getAppsOrderByNameExceptionTest(){
1120 List<EPApp> expected = null;
1121 EPUser epUser = new EPUser();
1122 final Map<String, Long> params = new HashMap<>();
1123 params.put("userId", null);
1124 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1125 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
1126 //Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap())).thenReturn(list);
1127 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByName(epUser);
1128 assertEquals(expected, actual);
1131 @SuppressWarnings("unchecked")
1133 public void getAppsOrderByLastUsedTest(){
1134 List<EPApp> expected = new ArrayList<EPApp>();
1135 EPUser epUser = new EPUser();
1136 List<EPApp> list = new ArrayList<EPApp>();
1137 final Map<String, Long> params = new HashMap<>();
1138 params.put("userId", (long)123);
1139 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1140 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAdminAppsOrderByLastUsed", params, null)).thenReturn(list);
1141 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByLastUsed(epUser);
1142 assertEquals(expected, actual);
1145 @SuppressWarnings("unchecked")
1147 public void getAppsOrderByLastUsedNotSuperAdminTest(){
1148 List<EPApp> expected = new ArrayList<EPApp>();
1149 EPUser epUser = new EPUser();
1150 List<EPApp> list = new ArrayList<EPApp>();
1151 final Map<String, Long> params = new HashMap<>();
1152 params.put("userId", (long)123);
1153 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(false);
1154 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAdminAppsOrderByLastUsed", params, null)).thenReturn(list);
1155 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByLastUsed(epUser);
1156 assertEquals(expected, actual);
1160 public void getAppsOrderByLastUsedExceptionTest(){
1161 List<EPApp> expected = new ArrayList<EPApp>();
1162 EPUser epUser = new EPUser();
1163 final Map<String, Long> params = new HashMap<>();
1164 params.put("userId", null);
1165 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
1166 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByLastUsed(epUser);
1167 assertEquals(expected, actual);
1170 @SuppressWarnings("unchecked")
1172 public void getAppsOrderByMostUsedTest(){
1173 List<EPApp> expected = new ArrayList<EPApp>();
1174 EPUser epUser = new EPUser();
1175 List<EPApp> list = new ArrayList<EPApp>();
1176 final Map<String, Long> params = new HashMap<>();
1177 params.put("userId", (long)123);
1178 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1179 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAppsOrderByMostUsed", params, null)).thenReturn(list);
1180 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByMostUsed(epUser);
1181 assertEquals(expected, actual);
1184 @SuppressWarnings("unchecked")
1186 public void getAppsOrderByMostUsedNotSuperAdminTest(){
1187 List<EPApp> expected = new ArrayList<EPApp>();
1188 EPUser epUser = new EPUser();
1189 List<EPApp> list = new ArrayList<EPApp>();
1190 final Map<String, Long> params = new HashMap<>();
1191 params.put("userId", (long)123);
1192 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(false);
1193 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAppsOrderByMostUsed", params, null)).thenReturn(list);
1194 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByMostUsed(epUser);
1195 assertEquals(expected, actual);
1199 public void getAppsOrderByMostUsedExceptionTest(){
1200 List<EPApp> expected = new ArrayList<EPApp>();
1201 EPUser epUser = new EPUser();
1202 final Map<String, Long> params = new HashMap<>();
1203 params.put("userId", null);
1204 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
1205 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByMostUsed(epUser);
1206 assertEquals(expected, actual);
1209 @SuppressWarnings("unchecked")
1211 public void getAppsOrderByManualTest(){
1212 List<EPApp> expected = new ArrayList<EPApp>();
1213 EPUser epUser = new EPUser();
1214 List<EPApp> list = new ArrayList<EPApp>();
1215 final Map<String, Long> params = new HashMap<>();
1216 params.put("userId", (long)123);
1217 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1218 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAdminAppsOrderByManual", params, null)).thenReturn(list);
1219 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByManual(epUser);
1220 assertEquals(expected, actual);
1223 @SuppressWarnings("unchecked")
1225 public void getAppsOrderByManualSuperAdminTest(){
1226 List<EPApp> expected = new ArrayList<EPApp>();
1227 EPUser epUser = new EPUser();
1228 List<EPApp> list = new ArrayList<EPApp>();
1229 final Map<String, Long> params = new HashMap<>();
1230 params.put("userId", (long)123);
1231 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(false);
1232 Mockito.when((List<EPApp>) dataAccessService.executeNamedQuery("getAdminAppsOrderByManual", params, null)).thenReturn(list);
1233 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByManual(epUser);
1234 assertEquals(expected, actual);
1237 @SuppressWarnings("unchecked")
1239 public void getAppsOrderByManualExceptionTest(){
1240 List<EPApp> expected = new ArrayList<EPApp>();
1241 EPUser epUser = new EPUser();
1242 List<EPApp> list = new ArrayList<EPApp>();
1243 final Map<String, Long> params = new HashMap<>();
1244 params.put("userId", null);
1245 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1246 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
1247 List<EPApp> actual = epAppCommonServiceImpl.getAppsOrderByManual(epUser);
1248 assertEquals(expected, actual);
1251 @SuppressWarnings("deprecation")
1253 public void getOnboardingAppsTest(){
1254 List<EPApp> apps = new ArrayList<EPApp>();
1255 List<OnboardingApp> expected = new ArrayList<OnboardingApp>();
1256 Mockito.when(dataAccessService.getList(EPApp.class, " where id!=" + ECOMP_APP_ID, null, null)).thenReturn(apps);
1257 List<OnboardingApp> actual = epAppCommonServiceImpl.getOnboardingApps();
1258 assertEquals(expected, actual);
1262 public void getEnabledNonOpenOnboardingAppsTest(){
1263 List<OnboardingApp> expected = new ArrayList<OnboardingApp>();
1264 List<OnboardingApp> actual = epAppCommonServiceImpl.getEnabledNonOpenOnboardingApps();
1265 assertEquals(expected, actual);
1269 public void addOnboardingAppTest(){
1270 FieldsValidator expected = new FieldsValidator();
1271 expected.setHttpStatusCode(400l);
1272 EPUser epUser = new EPUser();
1273 OnboardingApp onboardingApp = new OnboardingApp();
1275 onboardingApp.setRestrictedApp(true);
1276 onboardingApp.setRolesInAAF(false);
1277 onboardingApp.setIsEnabled(true);
1278 FieldsValidator actual = epAppCommonServiceImpl.addOnboardingApp(onboardingApp, epUser);
1279 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
1283 public void deleteOnboardingAppTest(){
1284 FieldsValidator expected = new FieldsValidator();
1285 expected.setHttpStatusCode(403l);
1286 EPUser epUser = new EPUser();
1287 Long appId = (long) 123;
1288 OnboardingApp onboardingApp = new OnboardingApp();
1289 onboardingApp.setRestrictedApp(true);
1290 FieldsValidator actual = epAppCommonServiceImpl.deleteOnboardingApp(epUser, appId);
1291 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
1294 @SuppressWarnings("unchecked")
1296 public void deleteOnboardingAppSuperAdminTest(){
1297 FieldsValidator expected = new FieldsValidator();
1298 expected.setHttpStatusCode(200l);
1299 EPUser epUser = new EPUser();
1300 Long appId = (long) 123;
1301 OnboardingApp onboardingApp = new OnboardingApp();
1302 onboardingApp.setRestrictedApp(true);
1303 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1304 final Map<String, Long> params = new HashMap<>();
1305 params.put("app_id", (long)123);
1306 EPUserAppRolesRequest epUserAppRolesRequest = new EPUserAppRolesRequest();
1307 epUserAppRolesRequest.setUserId((long)123);
1308 List<EPUserAppRolesRequest> list= new ArrayList<>();
1309 list.add(epUserAppRolesRequest);
1310 Mockito.when((List<EPUserAppRolesRequest>) dataAccessService.executeNamedQuery("getRequestIdsForApp", params, null)).thenReturn(list);
1311 FieldsValidator actual = epAppCommonServiceImpl.deleteOnboardingApp(epUser, appId);
1312 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
1315 @Test(expected=NullPointerException.class)
1316 public void deleteOnboardingAppExceptionTest(){
1317 FieldsValidator expected = new FieldsValidator();
1318 expected.setHttpStatusCode(200l);
1319 EPUser epUser = new EPUser();
1320 //Long appId = (long) 123;
1321 List<EPUserAppRolesRequest> epUserAppRolesRequestList= new ArrayList<>();
1322 OnboardingApp onboardingApp = new OnboardingApp();
1323 onboardingApp.setRestrictedApp(true);
1324 Mockito.when(adminRolesServiceImpl.isSuperAdmin(epUser)).thenReturn(true);
1325 final Map<String, Long> params = new HashMap<>();
1326 params.put("app_id", null);
1327 Mockito.when(dataAccessService.executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap())).thenThrow(nullPointerException);
1328 Mockito.when(dataAccessService.executeNamedQuery( "getRequestIdsForApp", params, null)).thenReturn(epUserAppRolesRequestList);
1329 //Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
1330 FieldsValidator actual = epAppCommonServiceImpl.deleteOnboardingApp(epUser, null);
1331 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
1334 @SuppressWarnings("unchecked")
1336 public void saveAppsSortManualAppIdNullTest(){
1337 List<EPUserAppsManualSortPreference> epUserAppsManualSortPreferenceList = new ArrayList<EPUserAppsManualSortPreference>();
1338 EPAppsManualPreference epAppsManualPreference = new EPAppsManualPreference();
1339 epAppsManualPreference.setAddRemoveApps(true);
1340 epAppsManualPreference.setAppid((long)123);
1341 FieldsValidator expected = new FieldsValidator();
1342 expected.setHttpStatusCode(200l);
1343 final Map<String, Long> params = new HashMap<>();
1344 params.put("userId", (long)123);
1345 EPUser epUser = new EPUser();
1346 List<EPAppsManualPreference> list = new ArrayList<EPAppsManualPreference>();
1347 list.add(epAppsManualPreference);
1348 Mockito.when(dataAccessService.executeNamedQuery("userAppsManualSortPrfQuery", params, null)).thenReturn(epUserAppsManualSortPreferenceList);
1349 FieldsValidator actual = epAppCommonServiceImpl.saveAppsSortManual(list, epUser);
1350 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
1354 public void saveAppsSortManualExceptionTest(){
1355 FieldsValidator expected = new FieldsValidator();
1356 expected.setHttpStatusCode(500l);
1357 final Map<String, Long> params = new HashMap<>();
1358 params.put("userId", (long)123);
1359 EPUser epUser = new EPUser();
1360 List<EPAppsManualPreference> list = new ArrayList<EPAppsManualPreference>();
1361 Mockito.doThrow(new NullPointerException()).when(dataAccessService).executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap());
1362 FieldsValidator actual = epAppCommonServiceImpl.saveAppsSortManual(list, epUser);
1363 assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
1367 public void getUserProfileForLeftMenuNullListTest(){
1368 UserRole userRole =new UserRole();
1369 userRole.setFirstName("test");
1370 UserRoles expected = null;
1371 UserRoles actual = epAppCommonServiceImpl.getUserProfileForLeftMenu("123");
1372 assertEquals(expected, actual);
1376 public void getUserProfileForLeftMenuTest(){
1377 final Map<String, String> params = new HashMap<>();
1378 params.put("org_user_id", "test");
1379 UserRole userRole =new UserRole();
1380 userRole.setFirstName("test");
1381 UserRoles expected = null;
1382 List<UserRole> list = new ArrayList<UserRole>();
1384 Mockito.when(dataAccessService.executeNamedQuery( "getUserRolesForLeftMenu", params, null)).thenReturn(list);
1385 UserRoles actual = epAppCommonServiceImpl.getUserProfileForLeftMenu("123");
1386 assertEquals(expected, actual);
1390 public void getUserProfileForRolesLeftMenuNullListTest(){
1391 UserRoles expected = null;
1392 List<UserRole> userRoleList = new ArrayList<UserRole>();
1393 final Map<String, String> params = new HashMap<>();
1394 params.put("org_user_id", "test");
1395 Mockito.when(dataAccessService.executeNamedQuery( "getRolesForLeftMenu", params, null)).thenReturn(userRoleList);
1396 UserRoles actual = epAppCommonServiceImpl.getUserProfileForRolesLeftMenu("test");
1397 assertEquals(expected, actual);
1401 public void getUserProfileForRolesLeftMenuTest(){
1402 UserRole userRole = new UserRole();
1403 userRole.setRoleId((long)123);
1404 userRole.setOrgUserId("test");
1405 userRole.setUser_Id((long)1);
1406 List<UserRole> userRoleList = new ArrayList<UserRole>();
1407 userRoleList.add(userRole);
1408 UserRoles expected = new UserRoles(userRole);
1409 final Map<String, String> params = new HashMap<>();
1410 params.put("org_user_id", "test");
1411 Mockito.when(dataAccessService.executeNamedQuery( "getRolesForLeftMenu", params, null)).thenReturn(userRoleList);
1412 UserRoles actual = epAppCommonServiceImpl.getUserProfileForRolesLeftMenu("test");
1413 assertEquals(expected.getOrgUserId(), actual.getOrgUserId());
1417 public void getUserProfileNormalizedForLeftMenuNullListTest(){
1418 EPUser epUser = new EPUser();
1419 List<String> list = new ArrayList<String>();
1421 UserRole userRole = new UserRole();
1422 userRole.setFirstName("GuestT");
1423 userRole.setLastName("GuestT");
1424 userRole.setOrgUserId("guestT");
1425 userRole.setRoleId(1l);
1426 userRole.setRoleName("Test");
1427 userRole.setUser_Id(-1l);
1428 UserRoles expected = new UserRoles(userRole);
1429 expected.setRoles(list);
1430 UserRoles actual = epAppCommonServiceImpl.getUserProfileNormalizedForLeftMenu(epUser);
1431 assertEquals(expected.getRoles(), actual.getRoles());
1435 public void getUserProfileNormalizedForRolesLeftMenuTest(){
1436 EPUser epUser = new EPUser();
1437 List<String> list = new ArrayList<String>();
1439 UserRole userRole = new UserRole();
1440 userRole.setFirstName("GuestT");
1441 userRole.setLastName("GuestT");
1442 userRole.setOrgUserId("guestT");
1443 userRole.setRoleId(1l);
1444 userRole.setRoleName("Test");
1445 userRole.setUser_Id(-1l);
1446 UserRoles expected = new UserRoles(userRole);
1447 expected.setRoles(list);
1448 UserRoles actual = epAppCommonServiceImpl.getUserProfileNormalizedForRolesLeftMenu(epUser);
1449 assertEquals(expected.getRoles(), actual.getRoles());
1452 @Test(expected = Exception.class)
1453 public void checkIfNameSpaceIsValidTest() throws Exception
1455 JSONObject mockJsonObject = new JSONObject();
1456 PowerMockito.mockStatic(EcompPortalUtils.class);
1457 ResponseEntity<String> getResponse = new ResponseEntity<>(HttpStatus.OK);
1458 Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET),
1459 Matchers.<HttpEntity<String>>any(), Matchers.eq(String.class))).thenReturn(getResponse);
1460 epAppCommonServiceImpl.checkIfNameSpaceIsValid("com.test");
1464 public void getAdminAppsOfUserTest()
1466 EPUser user = new EPUser();
1467 user.setId((long) 1);
1468 List<Integer> userAdminApps = new ArrayList<>();
1469 EPApp mockApp = mockApp();
1470 EPApp mockApp2 = mockApp();
1472 List<EPApp> appsList = new ArrayList<>();
1473 appsList.add(mockApp);
1474 appsList.add(mockApp2);
1475 Mockito.when((List<EPApp>) dataAccessService.getList(EPApp.class, " where id != " + ECOMP_APP_ID, "name", null))
1476 .thenReturn(appsList);
1477 Mockito.when(dataAccessService.executeNamedQuery(Matchers.anyString(), Matchers.anyMap(), Matchers.anyMap()))
1478 .thenReturn(userAdminApps);
1479 List<OnboardingApp> list = epAppCommonServiceImpl.getAdminAppsOfUser(user);
1480 assertEquals(list.size(), 0);